diff --git a/Cargo.lock b/Cargo.lock
index 0ae1dc4..089e0f2 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -1,12 +1,12 @@
 [root]
 name = "bindgen"
-version = "0.21.3"
+version = "0.22.0"
 dependencies = [
  "aster 0.38.0 (registry+https://github.com/rust-lang/crates.io-index)",
  "cexpr 0.2.0 (registry+https://github.com/rust-lang/crates.io-index)",
  "cfg-if 0.1.0 (registry+https://github.com/rust-lang/crates.io-index)",
  "clang-sys 0.14.0 (registry+https://github.com/rust-lang/crates.io-index)",
- "clap 2.19.3 (registry+https://github.com/rust-lang/crates.io-index)",
+ "clap 2.20.4 (registry+https://github.com/rust-lang/crates.io-index)",
  "diff 0.1.9 (registry+https://github.com/rust-lang/crates.io-index)",
  "env_logger 0.4.0 (registry+https://github.com/rust-lang/crates.io-index)",
  "lazy_static 0.2.2 (registry+https://github.com/rust-lang/crates.io-index)",
@@ -21,7 +21,7 @@
 
 [[package]]
 name = "aho-corasick"
-version = "0.6.1"
+version = "0.6.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 dependencies = [
  "memchr 1.0.1 (registry+https://github.com/rust-lang/crates.io-index)",
@@ -67,20 +67,20 @@
  "glob 0.2.11 (registry+https://github.com/rust-lang/crates.io-index)",
  "lazy_static 0.2.2 (registry+https://github.com/rust-lang/crates.io-index)",
  "libc 0.2.20 (registry+https://github.com/rust-lang/crates.io-index)",
- "libloading 0.3.1 (registry+https://github.com/rust-lang/crates.io-index)",
+ "libloading 0.3.2 (registry+https://github.com/rust-lang/crates.io-index)",
 ]
 
 [[package]]
 name = "clap"
-version = "2.19.3"
+version = "2.20.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 dependencies = [
  "ansi_term 0.9.0 (registry+https://github.com/rust-lang/crates.io-index)",
  "bitflags 0.7.0 (registry+https://github.com/rust-lang/crates.io-index)",
  "libc 0.2.20 (registry+https://github.com/rust-lang/crates.io-index)",
- "strsim 0.5.2 (registry+https://github.com/rust-lang/crates.io-index)",
- "term_size 0.2.1 (registry+https://github.com/rust-lang/crates.io-index)",
- "unicode-segmentation 0.1.3 (registry+https://github.com/rust-lang/crates.io-index)",
+ "strsim 0.6.0 (registry+https://github.com/rust-lang/crates.io-index)",
+ "term_size 0.2.2 (registry+https://github.com/rust-lang/crates.io-index)",
+ "unicode-segmentation 1.1.0 (registry+https://github.com/rust-lang/crates.io-index)",
  "unicode-width 0.1.4 (registry+https://github.com/rust-lang/crates.io-index)",
  "vec_map 0.6.0 (registry+https://github.com/rust-lang/crates.io-index)",
 ]
@@ -92,7 +92,7 @@
 
 [[package]]
 name = "dtoa"
-version = "0.2.2"
+version = "0.4.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 
 [[package]]
@@ -111,7 +111,7 @@
 
 [[package]]
 name = "itoa"
-version = "0.1.1"
+version = "0.3.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 
 [[package]]
@@ -135,12 +135,12 @@
 
 [[package]]
 name = "libloading"
-version = "0.3.1"
+version = "0.3.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 dependencies = [
  "kernel32-sys 0.2.2 (registry+https://github.com/rust-lang/crates.io-index)",
  "lazy_static 0.2.2 (registry+https://github.com/rust-lang/crates.io-index)",
- "target_build_utils 0.1.2 (registry+https://github.com/rust-lang/crates.io-index)",
+ "target_build_utils 0.3.0 (registry+https://github.com/rust-lang/crates.io-index)",
  "winapi 0.2.8 (registry+https://github.com/rust-lang/crates.io-index)",
 ]
 
@@ -234,7 +234,7 @@
 version = "0.2.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 dependencies = [
- "aho-corasick 0.6.1 (registry+https://github.com/rust-lang/crates.io-index)",
+ "aho-corasick 0.6.2 (registry+https://github.com/rust-lang/crates.io-index)",
  "memchr 1.0.1 (registry+https://github.com/rust-lang/crates.io-index)",
  "regex-syntax 0.4.0 (registry+https://github.com/rust-lang/crates.io-index)",
  "thread_local 0.3.2 (registry+https://github.com/rust-lang/crates.io-index)",
@@ -253,18 +253,18 @@
 
 [[package]]
 name = "serde"
-version = "0.8.23"
+version = "0.9.7"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 
 [[package]]
 name = "serde_json"
-version = "0.8.6"
+version = "0.9.6"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 dependencies = [
- "dtoa 0.2.2 (registry+https://github.com/rust-lang/crates.io-index)",
- "itoa 0.1.1 (registry+https://github.com/rust-lang/crates.io-index)",
+ "dtoa 0.4.1 (registry+https://github.com/rust-lang/crates.io-index)",
+ "itoa 0.3.1 (registry+https://github.com/rust-lang/crates.io-index)",
  "num-traits 0.1.36 (registry+https://github.com/rust-lang/crates.io-index)",
- "serde 0.8.23 (registry+https://github.com/rust-lang/crates.io-index)",
+ "serde 0.9.7 (registry+https://github.com/rust-lang/crates.io-index)",
 ]
 
 [[package]]
@@ -279,7 +279,7 @@
 
 [[package]]
 name = "strsim"
-version = "0.5.2"
+version = "0.6.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 
 [[package]]
@@ -300,7 +300,7 @@
  "log 0.3.6 (registry+https://github.com/rust-lang/crates.io-index)",
  "rustc-serialize 0.3.22 (registry+https://github.com/rust-lang/crates.io-index)",
  "syntex_pos 0.54.0 (registry+https://github.com/rust-lang/crates.io-index)",
- "term 0.4.4 (registry+https://github.com/rust-lang/crates.io-index)",
+ "term 0.4.5 (registry+https://github.com/rust-lang/crates.io-index)",
  "unicode-xid 0.0.4 (registry+https://github.com/rust-lang/crates.io-index)",
 ]
 
@@ -323,23 +323,23 @@
  "rustc-serialize 0.3.22 (registry+https://github.com/rust-lang/crates.io-index)",
  "syntex_errors 0.54.0 (registry+https://github.com/rust-lang/crates.io-index)",
  "syntex_pos 0.54.0 (registry+https://github.com/rust-lang/crates.io-index)",
- "term 0.4.4 (registry+https://github.com/rust-lang/crates.io-index)",
+ "term 0.4.5 (registry+https://github.com/rust-lang/crates.io-index)",
  "unicode-xid 0.0.4 (registry+https://github.com/rust-lang/crates.io-index)",
 ]
 
 [[package]]
 name = "target_build_utils"
-version = "0.1.2"
+version = "0.3.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 dependencies = [
  "phf 0.7.21 (registry+https://github.com/rust-lang/crates.io-index)",
  "phf_codegen 0.7.21 (registry+https://github.com/rust-lang/crates.io-index)",
- "serde_json 0.8.6 (registry+https://github.com/rust-lang/crates.io-index)",
+ "serde_json 0.9.6 (registry+https://github.com/rust-lang/crates.io-index)",
 ]
 
 [[package]]
 name = "term"
-version = "0.4.4"
+version = "0.4.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 dependencies = [
  "kernel32-sys 0.2.2 (registry+https://github.com/rust-lang/crates.io-index)",
@@ -348,7 +348,7 @@
 
 [[package]]
 name = "term_size"
-version = "0.2.1"
+version = "0.2.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 dependencies = [
  "kernel32-sys 0.2.2 (registry+https://github.com/rust-lang/crates.io-index)",
@@ -376,7 +376,7 @@
 
 [[package]]
 name = "unicode-segmentation"
-version = "0.1.3"
+version = "1.1.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 
 [[package]]
@@ -423,23 +423,23 @@
 source = "registry+https://github.com/rust-lang/crates.io-index"
 
 [metadata]
-"checksum aho-corasick 0.6.1 (registry+https://github.com/rust-lang/crates.io-index)" = "4f660b942762979b56c9f07b4b36bb559776fbad102f05d6771e1b629e8fd5bf"
+"checksum aho-corasick 0.6.2 (registry+https://github.com/rust-lang/crates.io-index)" = "0638fd549427caa90c499814196d1b9e3725eb4d15d7339d6de073a680ed0ca2"
 "checksum ansi_term 0.9.0 (registry+https://github.com/rust-lang/crates.io-index)" = "23ac7c30002a5accbf7e8987d0632fa6de155b7c3d39d0067317a391e00a2ef6"
 "checksum aster 0.38.0 (registry+https://github.com/rust-lang/crates.io-index)" = "2c9b49e42a449c0b79d8acb91db37621de0978064dca7d3288ddcf030123e5b3"
 "checksum bitflags 0.7.0 (registry+https://github.com/rust-lang/crates.io-index)" = "aad18937a628ec6abcd26d1489012cc0e18c21798210f491af69ded9b881106d"
 "checksum cexpr 0.2.0 (registry+https://github.com/rust-lang/crates.io-index)" = "393a5f0088efbe41f9d1fcd062f24e83c278608420e62109feb2c8abee07de7d"
 "checksum cfg-if 0.1.0 (registry+https://github.com/rust-lang/crates.io-index)" = "de1e760d7b6535af4241fca8bd8adf68e2e7edacc6b29f5d399050c5e48cf88c"
 "checksum clang-sys 0.14.0 (registry+https://github.com/rust-lang/crates.io-index)" = "4f98f0715ff67f27ca6a2f8f0ffc2a56f8edbc7acd57489c29eadc3a15c4eafe"
-"checksum clap 2.19.3 (registry+https://github.com/rust-lang/crates.io-index)" = "95b78f3fe0fc94c13c731714363260e04b557a637166f33a4570d3189d642374"
+"checksum clap 2.20.4 (registry+https://github.com/rust-lang/crates.io-index)" = "a60af5cb867dd4ee2378398acde80c73b466b58a963f598061ce7e394800998d"
 "checksum diff 0.1.9 (registry+https://github.com/rust-lang/crates.io-index)" = "e48977eec6d3b7707462c2dc2e1363ad91b5dd822cf942537ccdc2085dc87587"
-"checksum dtoa 0.2.2 (registry+https://github.com/rust-lang/crates.io-index)" = "0dd841b58510c9618291ffa448da2e4e0f699d984d436122372f446dae62263d"
+"checksum dtoa 0.4.1 (registry+https://github.com/rust-lang/crates.io-index)" = "80c8b71fd71146990a9742fc06dcbbde19161a267e0ad4e572c35162f4578c90"
 "checksum env_logger 0.4.0 (registry+https://github.com/rust-lang/crates.io-index)" = "99971fb1b635fe7a0ee3c4d065845bb93cca80a23b5613b5613391ece5de4144"
 "checksum glob 0.2.11 (registry+https://github.com/rust-lang/crates.io-index)" = "8be18de09a56b60ed0edf84bc9df007e30040691af7acd1c41874faac5895bfb"
-"checksum itoa 0.1.1 (registry+https://github.com/rust-lang/crates.io-index)" = "ae3088ea4baeceb0284ee9eea42f591226e6beaecf65373e41b38d95a1b8e7a1"
+"checksum itoa 0.3.1 (registry+https://github.com/rust-lang/crates.io-index)" = "eb2f404fbc66fd9aac13e998248505e7ecb2ad8e44ab6388684c5fb11c6c251c"
 "checksum kernel32-sys 0.2.2 (registry+https://github.com/rust-lang/crates.io-index)" = "7507624b29483431c0ba2d82aece8ca6cdba9382bff4ddd0f7490560c056098d"
 "checksum lazy_static 0.2.2 (registry+https://github.com/rust-lang/crates.io-index)" = "6abe0ee2e758cd6bc8a2cd56726359007748fbf4128da998b65d0b70f881e19b"
 "checksum libc 0.2.20 (registry+https://github.com/rust-lang/crates.io-index)" = "684f330624d8c3784fb9558ca46c4ce488073a8d22450415c5eb4f4cfb0d11b5"
-"checksum libloading 0.3.1 (registry+https://github.com/rust-lang/crates.io-index)" = "84816a8c6ed8163dfe0dbdd2b09d35c6723270ea77a4c7afa4bedf038a36cb99"
+"checksum libloading 0.3.2 (registry+https://github.com/rust-lang/crates.io-index)" = "fd1835a714c1f67ba073a493493c23686a480e2614e208c921834808b1f19d8f"
 "checksum log 0.3.6 (registry+https://github.com/rust-lang/crates.io-index)" = "ab83497bf8bf4ed2a74259c1c802351fcd67a65baa86394b6ba73c36f4838054"
 "checksum memchr 1.0.1 (registry+https://github.com/rust-lang/crates.io-index)" = "1dbccc0e46f1ea47b9f17e6d67c5a96bd27030519c519c9c91327e31275a47b4"
 "checksum nom 1.2.4 (registry+https://github.com/rust-lang/crates.io-index)" = "a5b8c256fd9471521bcb84c3cdba98921497f1a331cbc15b8030fc63b82050ce"
@@ -454,21 +454,21 @@
 "checksum regex 0.2.1 (registry+https://github.com/rust-lang/crates.io-index)" = "4278c17d0f6d62dfef0ab00028feb45bd7d2102843f80763474eeb1be8a10c01"
 "checksum regex-syntax 0.4.0 (registry+https://github.com/rust-lang/crates.io-index)" = "2f9191b1f57603095f105d317e375d19b1c9c5c3185ea9633a99a6dcbed04457"
 "checksum rustc-serialize 0.3.22 (registry+https://github.com/rust-lang/crates.io-index)" = "237546c689f20bb44980270c73c3b9edd0891c1be49cc1274406134a66d3957b"
-"checksum serde 0.8.23 (registry+https://github.com/rust-lang/crates.io-index)" = "9dad3f759919b92c3068c696c15c3d17238234498bbdcc80f2c469606f948ac8"
-"checksum serde_json 0.8.6 (registry+https://github.com/rust-lang/crates.io-index)" = "67f7d2e9edc3523a9c8ec8cd6ec481b3a27810aafee3e625d311febd3e656b4c"
+"checksum serde 0.9.7 (registry+https://github.com/rust-lang/crates.io-index)" = "1e0ed773960f90a78567fcfbe935284adf50c5d7cf119aa2cf43bb0b4afa69bb"
+"checksum serde_json 0.9.6 (registry+https://github.com/rust-lang/crates.io-index)" = "e095e4e94e7382b76f48e93bd845ffddda62df8dfd4c163b1bfa93d40e22e13a"
 "checksum shlex 0.1.1 (registry+https://github.com/rust-lang/crates.io-index)" = "7fdf1b9db47230893d76faad238fd6097fd6d6a9245cd7a4d90dbd639536bbd2"
 "checksum siphasher 0.2.1 (registry+https://github.com/rust-lang/crates.io-index)" = "2ffc669b726f2bc9a3bcff66e5e23b56ba6bf70e22a34c3d7b6d0b3450b65b84"
-"checksum strsim 0.5.2 (registry+https://github.com/rust-lang/crates.io-index)" = "67f84c44fbb2f91db7fef94554e6b2ac05909c9c0b0bc23bb98d3a1aebfe7f7c"
+"checksum strsim 0.6.0 (registry+https://github.com/rust-lang/crates.io-index)" = "b4d15c810519a91cf877e7e36e63fe068815c678181439f2f29e2562147c3694"
 "checksum syntex 0.54.0 (registry+https://github.com/rust-lang/crates.io-index)" = "bb3f52553a966675982404dc34028291b347e0c9a9c0b0b34f2da6be8a0443f8"
 "checksum syntex_errors 0.54.0 (registry+https://github.com/rust-lang/crates.io-index)" = "dee2f6e49c075f71332bb775219d5982bee6732d26227fa1ae1b53cdb12f5cc5"
 "checksum syntex_pos 0.54.0 (registry+https://github.com/rust-lang/crates.io-index)" = "8df3921c7945dfb9ffc53aa35adb2cf4313b5ab5f079c3619b3d4eb82a0efc2b"
 "checksum syntex_syntax 0.54.0 (registry+https://github.com/rust-lang/crates.io-index)" = "dc960085bae44591e22d01f6c0e82a8aec832f8659aca556cdf8ecbdac2bb47b"
-"checksum target_build_utils 0.1.2 (registry+https://github.com/rust-lang/crates.io-index)" = "54c550e226618cd35334b75e92bfa5437c61474bdb75c38bf330ab5a8037b77c"
-"checksum term 0.4.4 (registry+https://github.com/rust-lang/crates.io-index)" = "3deff8a2b3b6607d6d7cc32ac25c0b33709453ca9cceac006caac51e963cf94a"
-"checksum term_size 0.2.1 (registry+https://github.com/rust-lang/crates.io-index)" = "3f7f5f3f71b0040cecc71af239414c23fd3c73570f5ff54cf50e03cef637f2a0"
+"checksum target_build_utils 0.3.0 (registry+https://github.com/rust-lang/crates.io-index)" = "f42dc058080c19c6a58bdd1bf962904ee4f5ef1fe2a81b529f31dacc750c679f"
+"checksum term 0.4.5 (registry+https://github.com/rust-lang/crates.io-index)" = "d168af3930b369cfe245132550579d47dfd873d69470755a19c2c6568dbbd989"
+"checksum term_size 0.2.2 (registry+https://github.com/rust-lang/crates.io-index)" = "71662702fe5cd2cf95edd4ad655eea42f24a87a0e44059cbaa4e55260b7bc331"
 "checksum thread-id 3.0.0 (registry+https://github.com/rust-lang/crates.io-index)" = "4437c97558c70d129e40629a5b385b3fb1ffac301e63941335e4d354081ec14a"
 "checksum thread_local 0.3.2 (registry+https://github.com/rust-lang/crates.io-index)" = "7793b722f0f77ce716e7f1acf416359ca32ff24d04ffbac4269f44a4a83be05d"
-"checksum unicode-segmentation 0.1.3 (registry+https://github.com/rust-lang/crates.io-index)" = "c3bc443ded17b11305ffffe6b37e2076f328a5a8cb6aa877b1b98f77699e98b5"
+"checksum unicode-segmentation 1.1.0 (registry+https://github.com/rust-lang/crates.io-index)" = "18127285758f0e2c6cf325bb3f3d138a12fee27de4f23e146cd6a179f26c2cf3"
 "checksum unicode-width 0.1.4 (registry+https://github.com/rust-lang/crates.io-index)" = "bf3a113775714a22dcb774d8ea3655c53a32debae63a063acc00a91cc586245f"
 "checksum unicode-xid 0.0.4 (registry+https://github.com/rust-lang/crates.io-index)" = "8c1f860d7d29cf02cb2f3f359fd35991af3d30bac52c57d265a3c461074cb4dc"
 "checksum unreachable 0.1.1 (registry+https://github.com/rust-lang/crates.io-index)" = "1f2ae5ddb18e1c92664717616dd9549dde73f539f01bd7b77c2edb2446bdff91"
diff --git a/Cargo.toml b/Cargo.toml
index c732337..a9521be 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -13,7 +13,7 @@
 readme = "README.md"
 repository = "https://github.com/servo/rust-bindgen"
 documentation = "https://docs.rs/bindgen"
-version = "0.21.3"
+version = "0.22.0"
 build = "build.rs"
 
 exclude = ["tests/headers", "tests/expectations", "bindgen-integration", "ci"]
diff --git a/build.rs b/build.rs
index c3633cd..4e99c77 100644
--- a/build.rs
+++ b/build.rs
@@ -11,6 +11,7 @@
         quasi_codegen::expand(&src, &dst).unwrap();
         println!("cargo:rerun-if-changed=src/codegen/mod.rs");
         println!("cargo:rerun-if-changed=src/codegen/helpers.rs");
+        println!("cargo:rerun-if-changed=src/codegen/struct_layout.rs");
     }
 }
 
diff --git a/src/codegen/mod.rs b/src/codegen/mod.rs
index ad6736b..77f654e 100644
--- a/src/codegen/mod.rs
+++ b/src/codegen/mod.rs
@@ -2,7 +2,8 @@
 mod struct_layout;
 
 use self::helpers::{BlobTyBuilder, attributes};
-use self::struct_layout::StructLayoutTracker;
+use self::struct_layout::{align_to, bytes_from_bits};
+use self::struct_layout::{bytes_from_bits_pow2, StructLayoutTracker};
 use aster;
 
 use ir::annotations::FieldAccessorKind;
@@ -363,8 +364,7 @@
             }
 
             if item.id() == ctx.root_module() {
-                let saw_union = result.saw_union;
-                if saw_union && !ctx.options().unstable_rust {
+                if result.saw_union && !ctx.options().unstable_rust {
                     utils::prepend_union_types(ctx, &mut *result);
                 }
                 if result.saw_incomplete_array {
@@ -717,12 +717,12 @@
 }
 
 struct Bitfield<'a> {
-    index: usize,
+    index: &'a mut usize,
     fields: Vec<&'a Field>,
 }
 
 impl<'a> Bitfield<'a> {
-    fn new(index: usize, fields: Vec<&'a Field>) -> Self {
+    fn new(index: &'a mut usize, fields: Vec<&'a Field>) -> Self {
         Bitfield {
             index: index,
             fields: fields,
@@ -732,89 +732,96 @@
     fn codegen_fields(self,
                       ctx: &BindgenContext,
                       fields: &mut Vec<ast::StructField>,
-                      methods: &mut Vec<ast::ImplItem>)
+                      _methods: &mut Vec<ast::ImplItem>)
                       -> Layout {
         use aster::struct_field::StructFieldBuilder;
-        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;
+        // NOTE: What follows is reverse-engineered from LLVM's
+        // lib/AST/RecordLayoutBuilder.cpp
+        //
+        // FIXME(emilio): There are some differences between Microsoft and the
+        // Itanium ABI, but we'll ignore those and stick to Itanium for now.
+        //
+        // Also, we need to handle packed bitfields and stuff.
+        // TODO(emilio): Take into account C++'s wide bitfields, and
+        // packing, sigh.
+        let mut total_size_in_bits = 0;
+        let mut max_align = 0;
+        let mut unfilled_bits_in_last_unit = 0;
+        let mut field_size_in_bits = 0;
+        *self.index += 1;
+        let mut last_field_name = format!("_bitfield_{}", self.index);
+        let mut last_field_align = 0;
 
-        let bitfield_layout = Layout::new(total_width_in_bytes,
-                                          total_width_in_bytes);
-        let bitfield_type = BlobTyBuilder::new(bitfield_layout).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 mut offset = 0;
         for field in self.fields {
             let width = field.bitfield().unwrap();
-            let field_name = field.name()
-                .map(ToOwned::to_owned)
-                .unwrap_or_else(|| format!("at_offset_{}", offset));
-
             let field_item = ctx.resolve_item(field.ty());
             let field_ty_layout = field_item.kind()
                 .expect_type()
                 .layout(ctx)
                 .expect("Bitfield without layout? Gah!");
 
-            let field_type = field_item.to_rust_ty(ctx);
-            let int_type = BlobTyBuilder::new(field_ty_layout).build();
+            let field_align = field_ty_layout.align;
 
-            let getter_name = ctx.rust_ident(&field_name);
-            let setter_name = ctx.ext_cx()
-                .ident_of(&format!("set_{}", &field_name));
-            let mask = ((1usize << width) - 1) << offset;
-            let prefix = ctx.trait_prefix();
-            // The transmute is unfortunate, but it's needed for enums in
-            // bitfields.
-            let item = quote_item!(ctx.ext_cx(),
-                impl X {
-                    #[inline]
-                    pub fn $getter_name(&self) -> $field_type {
-                        unsafe {
-                            ::$prefix::mem::transmute(
-                                (
-                                    (self.$field_ident &
-                                        ($mask as $bitfield_type))
-                                     >> $offset
-                                ) as $int_type
-                            )
-                        }
-                    }
+            if field_size_in_bits != 0 &&
+                (width == 0 || width as usize > unfilled_bits_in_last_unit) {
+                field_size_in_bits = align_to(field_size_in_bits, field_align);
+                // Push the new field.
+                let ty =
+                    BlobTyBuilder::new(Layout::new(bytes_from_bits_pow2(field_size_in_bits),
+                                                   bytes_from_bits_pow2(last_field_align)))
+                        .build();
 
-                    #[inline]
-                    pub fn $setter_name(&mut self, val: $field_type) {
-                        self.$field_ident &= !($mask as $bitfield_type);
-                        self.$field_ident |=
-                            (val as $int_type as $bitfield_type << $offset) &
-                                ($mask as $bitfield_type);
-                    }
-                }
-            )
-                .unwrap();
+                let field = StructFieldBuilder::named(&last_field_name)
+                    .pub_()
+                    .build_ty(ty);
+                fields.push(field);
 
-            let items = match item.unwrap().node {
-                ast::ItemKind::Impl(_, _, _, _, _, items) => items,
-                _ => unreachable!(),
-            };
+                // TODO(emilio): dedup this.
+                *self.index += 1;
+                last_field_name = format!("_bitfield_{}", self.index);
 
-            methods.extend(items.into_iter());
-            offset += width;
+                // Now reset the size and the rest of stuff.
+                // unfilled_bits_in_last_unit = 0;
+                field_size_in_bits = 0;
+                last_field_align = 0;
+            }
+
+            // TODO(emilio): Create the accessors. Problem here is that we still
+            // don't know which one is going to be the final alignment of the
+            // bitfield, and whether we have to index in it. Thus, we don't know
+            // which integer type do we need.
+            //
+            // We could push them to a Vec or something, but given how buggy
+            // they where maybe it's not a great idea?
+            field_size_in_bits += width as usize;
+            total_size_in_bits += width as usize;
+
+
+            let data_size = align_to(field_size_in_bits, field_align * 8);
+
+            max_align = cmp::max(max_align, field_align);
+
+            // NB: The width here is completely, absolutely intentional.
+            last_field_align = cmp::max(last_field_align, width as usize);
+
+            unfilled_bits_in_last_unit = data_size - field_size_in_bits;
         }
 
-        bitfield_layout
+        if field_size_in_bits != 0 {
+            // Push the last field.
+            let ty =
+                BlobTyBuilder::new(Layout::new(bytes_from_bits_pow2(field_size_in_bits),
+                                               bytes_from_bits_pow2(last_field_align)))
+                    .build();
+
+            let field = StructFieldBuilder::named(&last_field_name)
+                .pub_()
+                .build_ty(ty);
+            fields.push(field);
+        }
+
+        Layout::new(bytes_from_bits(total_size_in_bits), max_align)
     }
 }
 
@@ -1062,12 +1069,10 @@
                 debug_assert!(!current_bitfield_fields.is_empty());
                 let bitfield_fields =
                     mem::replace(&mut current_bitfield_fields, vec![]);
-                bitfield_count += 1;
-                let bitfield_layout = Bitfield::new(bitfield_count,
+                let bitfield_layout = Bitfield::new(&mut bitfield_count,
                                                     bitfield_fields)
                     .codegen_fields(ctx, &mut fields, &mut methods);
-
-                struct_layout.saw_bitfield(bitfield_layout);
+                struct_layout.saw_bitfield_batch(bitfield_layout);
 
                 current_bitfield_width = None;
                 current_bitfield_layout = None;
@@ -1099,8 +1104,7 @@
                 } else {
                     quote_ty!(ctx.ext_cx(), __BindgenUnionField<$ty>)
                 }
-            } else if let Some(item) =
-                field_ty.is_incomplete_array(ctx) {
+            } else if let Some(item) = field_ty.is_incomplete_array(ctx) {
                 result.saw_incomplete_array();
 
                 let inner = item.to_rust_ty(ctx);
@@ -1224,12 +1228,10 @@
             debug_assert!(!current_bitfield_fields.is_empty());
             let bitfield_fields = mem::replace(&mut current_bitfield_fields,
                                                vec![]);
-            bitfield_count += 1;
-            let bitfield_layout = Bitfield::new(bitfield_count,
+            let bitfield_layout = Bitfield::new(&mut bitfield_count,
                                                 bitfield_fields)
                 .codegen_fields(ctx, &mut fields, &mut methods);
-
-            struct_layout.saw_bitfield(bitfield_layout);
+            struct_layout.saw_bitfield_batch(bitfield_layout);
         }
         debug_assert!(current_bitfield_fields.is_empty());
 
@@ -1268,7 +1270,7 @@
             }
         } else if !is_union && !self.is_unsized(ctx) {
             if let Some(padding_field) =
-                layout.and_then(|layout| struct_layout.pad_struct(layout)) {
+                layout.and_then(|layout| struct_layout.pad_struct(&canonical_name, layout)) {
                 fields.push(padding_field);
             }
 
@@ -2174,8 +2176,8 @@
                 quote_ty!(ctx.ext_cx(), ::$prefix::option::Option<$ty>)
             }
             TypeKind::Array(item, len) => {
-                let inner = item.to_rust_ty(ctx);
-                aster::ty::TyBuilder::new().array(len).build(inner)
+                let ty = item.to_rust_ty(ctx);
+                aster::ty::TyBuilder::new().array(len).build(ty)
             }
             TypeKind::Enum(..) => {
                 let path = item.namespace_aware_canonical_path(ctx);
@@ -2190,7 +2192,7 @@
                         .map(|arg| arg.to_rust_ty(ctx))
                         .collect::<Vec<_>>();
 
-                    path.segments.last_mut().unwrap().parameters = if 
+                    path.segments.last_mut().unwrap().parameters = if
                         template_args.is_empty() {
                         None
                     } else {
diff --git a/src/codegen/struct_layout.rs b/src/codegen/struct_layout.rs
index f8a88bc..24938c1 100644
--- a/src/codegen/struct_layout.rs
+++ b/src/codegen/struct_layout.rs
@@ -7,7 +7,7 @@
 use ir::comp::CompInfo;
 use ir::context::BindgenContext;
 use ir::layout::Layout;
-use ir::ty::Type;
+use ir::ty::{Type, TypeKind};
 use std::cmp;
 use std::mem;
 
@@ -21,6 +21,84 @@
     padding_count: usize,
     latest_field_layout: Option<Layout>,
     max_field_align: usize,
+    last_field_was_bitfield: bool,
+}
+
+/// Returns a size aligned to a given value.
+pub fn align_to(size: usize, align: usize) -> usize {
+    if align == 0 {
+        return size;
+    }
+
+    let rem = size % align;
+    if rem == 0 {
+        return size;
+    }
+
+    size + align - rem
+}
+
+/// Returns the amount of bytes from a given amount of bytes, rounding up.
+pub fn bytes_from_bits(n: usize) -> usize {
+    if n % 8 == 0 {
+        return n / 8;
+    }
+
+    n / 8 + 1
+}
+
+/// Returns the lower power of two byte count that can hold at most n bits.
+pub fn bytes_from_bits_pow2(mut n: usize) -> usize {
+    if n == 0 {
+        return 0;
+    }
+
+    if n <= 8 {
+        return 1;
+    }
+
+    if !n.is_power_of_two() {
+        n = n.next_power_of_two();
+    }
+
+    n / 8
+}
+
+#[test]
+fn test_align_to() {
+    assert_eq!(align_to(1, 1), 1);
+    assert_eq!(align_to(1, 2), 2);
+    assert_eq!(align_to(1, 4), 4);
+    assert_eq!(align_to(5, 1), 5);
+    assert_eq!(align_to(17, 4), 20);
+}
+
+#[test]
+fn test_bytes_from_bits_pow2() {
+    assert_eq!(bytes_from_bits_pow2(0), 0);
+    for i in 1..9 {
+        assert_eq!(bytes_from_bits_pow2(i), 1);
+    }
+    for i in 9..17 {
+        assert_eq!(bytes_from_bits_pow2(i), 2);
+    }
+    for i in 17..33 {
+        assert_eq!(bytes_from_bits_pow2(i), 4);
+    }
+}
+
+#[test]
+fn test_bytes_from_bits() {
+    assert_eq!(bytes_from_bits(0), 0);
+    for i in 1..9 {
+        assert_eq!(bytes_from_bits(i), 1);
+    }
+    for i in 9..17 {
+        assert_eq!(bytes_from_bits(i), 2);
+    }
+    for i in 17..25 {
+        assert_eq!(bytes_from_bits(i), 3);
+    }
 }
 
 impl<'a, 'ctx> StructLayoutTracker<'a, 'ctx> {
@@ -32,6 +110,7 @@
             padding_count: 0,
             latest_field_layout: None,
             max_field_align: 0,
+            last_field_was_bitfield: false,
         }
     }
 
@@ -43,112 +122,149 @@
     }
 
     pub fn saw_base(&mut self, base_ty: &Type) {
-        self.align_to_latest_field();
-
         if let Some(layout) = base_ty.layout(self.ctx) {
+            self.align_to_latest_field(layout);
+
             self.latest_offset += self.padding_bytes(layout) + layout.size;
             self.latest_field_layout = Some(layout);
             self.max_field_align = cmp::max(self.max_field_align, layout.align);
         }
     }
 
-    pub fn saw_bitfield(&mut self, layout: Layout) {
-        self.align_to_latest_field();
+    pub fn saw_bitfield_batch(&mut self, layout: Layout) {
+        self.align_to_latest_field(layout);
 
-        self.latest_offset += self.padding_bytes(layout) + layout.size;
+        self.latest_offset += layout.size;
+
+        debug!("Offset: <bitfield>: {} -> {}",
+               self.latest_offset - layout.size,
+               self.latest_offset);
+
         self.latest_field_layout = Some(layout);
-        self.max_field_align = cmp::max(self.max_field_align, layout.align);
+        self.last_field_was_bitfield = true;
+        // NB: We intentionally don't update the max_field_align here, since our
+        // bitfields code doesn't necessarily guarantee it, so we need to
+        // actually generate the dummy alignment.
     }
 
     pub fn saw_union(&mut self, layout: Layout) {
-        self.align_to_latest_field();
+        self.align_to_latest_field(layout);
 
         self.latest_offset += self.padding_bytes(layout) + layout.size;
         self.latest_field_layout = Some(layout);
         self.max_field_align = cmp::max(self.max_field_align, layout.align);
     }
 
+    /// Add a padding field if necessary for a given new field _before_ adding
+    /// that field.
     pub fn pad_field(&mut self,
                      field_name: &str,
                      field_ty: &Type,
                      field_offset: Option<usize>)
                      -> Option<ast::StructField> {
-        field_ty.layout(self.ctx).and_then(|field_layout| {
-            self.align_to_latest_field();
+        let mut field_layout = match field_ty.layout(self.ctx) {
+            Some(l) => l,
+            None => return None,
+        };
 
-            let padding_layout = if self.comp.packed() {
-                None
-            } else {
-                let calculated_layout = field_ty.as_comp()
-                    .and_then(|comp| comp.calc_layout(self.ctx))
-                    .unwrap_or(field_layout);
-
-                let align = cmp::min(calculated_layout.align, mem::size_of::<*mut ()>());
-
-                let (padding_bytes, need_padding) = match field_offset {
-                    Some(offset) if offset / 8  > self.latest_offset => {
-                        (offset / 8  - self.latest_offset, true)
-                    }
-                    _ if field_layout.align != 0 => {
-                        (self.padding_bytes(field_layout), (self.latest_offset % field_layout.align) != 0)
-                    }
-                    _ => {
-                        (0, false)
-                    }
-                };
-
-                self.latest_offset += padding_bytes;
-
-                debug!("align field {} to {}/{} with {} padding bytes {:?}, calculated {:?}",
-                    field_name,
-                    self.latest_offset,
-                    field_offset.unwrap_or(0) / 8,
-                    padding_bytes,
-                    field_layout,
-                    calculated_layout);
-
-                if need_padding &&
-                   (padding_bytes > calculated_layout.align ||
-                    field_layout.align > mem::size_of::<*mut ()>()) {
-                    Some(Layout::new(padding_bytes, align))
-                } else {
-                    None
+        if let TypeKind::Array(inner, len) = *field_ty.canonical_type(self.ctx).kind() {
+            // FIXME(emilio): As an _ultra_ hack, we correct the layout returned
+            // by arrays of structs that have a bigger alignment than what we
+            // can support.
+            //
+            // This means that the structs in the array are super-unsafe to
+            // access, since they won't be properly aligned, but *shrug*.
+            if let Some(layout) = self.ctx.resolve_type(inner).layout(self.ctx) {
+                if layout.align > mem::size_of::<*mut ()>() {
+                    field_layout.size =
+                        align_to(layout.size, layout.align) * len;
+                    field_layout.align = mem::size_of::<*mut ()>();
                 }
-            };
+            }
+        }
 
-            self.latest_offset += field_ty.calc_size(self.ctx).unwrap_or(field_layout.size);
+        let will_merge_with_bitfield = self.align_to_latest_field(field_layout);
 
-            self.latest_field_layout = Some(field_layout);
-            self.max_field_align = cmp::max(self.max_field_align, field_layout.align);
-
-            padding_layout.map(|layout| self.padding_field(layout))
-        })
-    }
-
-    pub fn pad_struct(&mut self, layout: Layout) -> Option<ast::StructField> {
-        if layout.size < self.latest_offset {
-            warn!("calculate struct layout incorrect, too more {} bytes",
-                  self.latest_offset - layout.size);
-
+        let padding_layout = if self.comp.packed() {
             None
         } else {
-            let padding_bytes = layout.size - self.latest_offset;
-            let struct_align = cmp::min(layout.align,
-                                        mem::size_of::<*mut ()>());
+            let padding_bytes = match field_offset {
+                Some(offset) if offset / 8 > self.latest_offset => {
+                    offset / 8 - self.latest_offset
+                }
+                _ if will_merge_with_bitfield || field_layout.align == 0 => 0,
+                _ => self.padding_bytes(field_layout),
+            };
 
-            if padding_bytes > struct_align ||
-               (layout.align > mem::size_of::<*mut ()>() && padding_bytes > 0) {
-                let padding_align = if self.comp.packed() {
-                    1
-                } else {
-                    cmp::min(1 << padding_bytes.trailing_zeros(),
-                             mem::size_of::<*mut ()>())
-                };
+            // Otherwise the padding is useless.
+            let need_padding = padding_bytes >= field_layout.align;
 
-                Some(self.padding_field(Layout::new(padding_bytes, padding_align)))
+            self.latest_offset += padding_bytes;
+
+            debug!("Offset: <padding>: {} -> {}",
+                   self.latest_offset - padding_bytes,
+                   self.latest_offset);
+
+            debug!("align field {} to {}/{} with {} padding bytes {:?}",
+                field_name,
+                self.latest_offset,
+                field_offset.unwrap_or(0) / 8,
+                padding_bytes,
+                field_layout);
+
+            if need_padding && padding_bytes != 0 {
+                Some(Layout::new(padding_bytes, field_layout.align))
             } else {
                 None
             }
+        };
+
+        self.latest_offset += field_layout.size;
+        self.latest_field_layout = Some(field_layout);
+        self.max_field_align = cmp::max(self.max_field_align, field_layout.align);
+        self.last_field_was_bitfield = false;
+
+        debug!("Offset: {}: {} -> {}",
+               field_name,
+               self.latest_offset - field_layout.size,
+               self.latest_offset);
+
+        padding_layout.map(|layout| self.padding_field(layout))
+    }
+
+    pub fn pad_struct(&mut self, name: &str, layout: Layout) -> Option<ast::StructField> {
+        if layout.size < self.latest_offset {
+            error!("Calculated wrong layout for {}, too more {} bytes",
+                   name, self.latest_offset - layout.size);
+            return None
+        }
+
+        let padding_bytes = layout.size - self.latest_offset;
+
+        // We always pad to get to the correct size if the struct is one of
+        // those we can't align properly.
+        //
+        // Note that if the last field we saw was a bitfield, we may need to pad
+        // regardless, because bitfields don't respect alignment as strictly as
+        // other fields.
+        if padding_bytes > 0 &&
+            (padding_bytes >= layout.align ||
+             (self.last_field_was_bitfield &&
+                padding_bytes >= self.latest_field_layout.unwrap().align) ||
+             layout.align > mem::size_of::<*mut ()>()) {
+            let layout = if self.comp.packed() {
+                Layout::new(padding_bytes, 1)
+            } else if self.last_field_was_bitfield ||
+                      layout.align > mem::size_of::<*mut ()>() {
+                // We've already given up on alignment here.
+                Layout::for_size(padding_bytes)
+            } else {
+                Layout::new(padding_bytes, layout.align)
+            };
+
+            Some(self.padding_field(layout))
+        } else {
+            None
         }
     }
 
@@ -166,15 +282,7 @@
     }
 
     fn padding_bytes(&self, layout: Layout) -> usize {
-        if layout.align == 0 {
-            warn!("try to padding bytes without layout");
-
-            0
-        } else if self.latest_offset % layout.align == 0 {
-            0
-        } else {
-            layout.align - (self.latest_offset % layout.align)
-        }
+        align_to(self.latest_offset, layout.align) - self.latest_offset
     }
 
     fn padding_field(&mut self, layout: Layout) -> ast::StructField {
@@ -190,11 +298,37 @@
         StructFieldBuilder::named(padding_field_name).pub_().build_ty(ty)
     }
 
-    fn align_to_latest_field(&mut self) {
+    /// Returns whether the new field is known to merge with a bitfield.
+    ///
+    /// This is just to avoid doing the same check also in pad_field.
+    fn align_to_latest_field(&mut self, new_field_layout: Layout) -> bool {
         if self.comp.packed() {
-            // skip to align field when packed
-        } else if let Some(layout) = self.latest_field_layout {
-            self.latest_offset += self.padding_bytes(layout);
+            // Skip to align fields when packed.
+            return false;
         }
+
+        let layout = match self.latest_field_layout {
+            Some(l) => l,
+            None => return false,
+        };
+
+        // If it was, we may or may not need to align, depending on what the
+        // current field alignment and the bitfield size and alignment are.
+        debug!("align_to_bitfield? {}: {:?} {:?}", self.last_field_was_bitfield,
+               layout, new_field_layout);
+
+        if self.last_field_was_bitfield &&
+            new_field_layout.align <= layout.size % layout.align &&
+            new_field_layout.size <= layout.size % layout.align {
+            // The new field will be coalesced into some of the remaining bits.
+            //
+            // FIXME(emilio): I think this may not catch everything?
+            debug!("Will merge with bitfield");
+            return true;
+        }
+
+        // Else, just align the obvious way.
+        self.latest_offset += self.padding_bytes(layout);
+        return false;
     }
 }
diff --git a/src/ir/comp.rs b/src/ir/comp.rs
index fff4655..ce6ec25 100644
--- a/src/ir/comp.rs
+++ b/src/ir/comp.rs
@@ -408,73 +408,25 @@
     /// members. This is not ideal, but clang fails to report the size for these
     /// kind of unions, see test/headers/template_union.hpp
     pub fn layout(&self, ctx: &BindgenContext) -> Option<Layout> {
+        use std::cmp;
         // We can't do better than clang here, sorry.
         if self.kind == CompKind::Struct {
-            None
-        } else {
-            self.calc_layout(ctx)
+            return None
         }
-    }
 
-    /// Compute the layout of this type.
-    pub fn calc_layout(&self, ctx: &BindgenContext) -> Option<Layout> {
-        use std::cmp;
-        use std::mem;
+        let mut max_size = 0;
+        let mut max_align = 0;
+        for field in &self.fields {
+            let field_layout = ctx.resolve_type(field.ty)
+                .layout(ctx);
 
-        if self.kind == CompKind::Struct {
-            let mut latest_offset_in_bits = 0;
-            let mut max_align = 0;
-
-            if self.needs_explicit_vtable(ctx) {
-                latest_offset_in_bits += mem::size_of::<*mut ()>() * 8;
-                max_align = mem::size_of::<*mut ()>();
+            if let Some(layout) = field_layout {
+                max_size = cmp::max(max_size, layout.size);
+                max_align = cmp::max(max_align, layout.align);
             }
-
-            for field in &self.fields {
-                if let Some(bits) = field.bitfield() {
-                    latest_offset_in_bits += bits as usize;
-                } else {
-                    let field_ty = ctx.resolve_type(field.ty);
-
-                    if let Some(field_layout) =
-                        field_ty.as_comp()
-                            .and_then(|comp| comp.calc_layout(ctx))
-                            .or_else(|| field_ty.layout(ctx)) {
-
-                        let n = (latest_offset_in_bits / 8) %
-                                field_layout.align;
-
-                        if !self.packed && n != 0 {
-                            latest_offset_in_bits += (field_layout.align - n) *
-                                                     8;
-                        }
-
-                        latest_offset_in_bits += field_layout.size * 8;
-                        max_align = cmp::max(max_align, field_layout.align);
-                    }
-                }
-            }
-
-            if latest_offset_in_bits == 0 && max_align == 0 {
-                None
-            } else {
-                Some(Layout::new((latest_offset_in_bits + 7) / 8, max_align))
-            }
-        } else {
-            let mut max_size = 0;
-            let mut max_align = 0;
-            for field in &self.fields {
-                let field_layout = ctx.resolve_type(field.ty)
-                    .layout(ctx);
-
-                if let Some(layout) = field_layout {
-                    max_size = cmp::max(max_size, layout.size);
-                    max_align = cmp::max(max_align, layout.align);
-                }
-            }
-
-            Some(Layout::new(max_size, max_align))
         }
+
+        Some(Layout::new(max_size, max_align))
     }
 
     /// Get this type's set of fields.
diff --git a/src/ir/enum_ty.rs b/src/ir/enum_ty.rs
index 0a85577..3470e03 100644
--- a/src/ir/enum_ty.rs
+++ b/src/ir/enum_ty.rs
@@ -5,8 +5,6 @@
 use super::ty::TypeKind;
 use clang;
 use ir::annotations::Annotations;
-use ir::int::IntKind;
-use ir::layout::Layout;
 use parse::{ClangItemParser, ParseError};
 
 /// An enum representing custom handling that can be given to a variant.
@@ -51,19 +49,6 @@
         &self.variants
     }
 
-    /// Compute the layout of this type.
-    pub fn calc_layout(&self, ctx: &BindgenContext) -> Option<Layout> {
-        self.repr
-            .map(|repr| ctx.resolve_type(repr))
-            .and_then(|repr| match *repr.canonical_type(ctx).kind() {
-                TypeKind::Int(int_kind) => Some(int_kind),
-                _ => None,
-            })
-            .unwrap_or(IntKind::Int)
-            .known_size()
-            .map(|size| Layout::new(size, size))
-    }
-
     /// Construct an enumeration from the given Clang type.
     pub fn from_ty(ty: &clang::Type,
                    ctx: &mut BindgenContext)
@@ -114,7 +99,7 @@
                             Annotations::new(&cursor)
                                 .and_then(|anno| if anno.hide() {
                                     Some(EnumVariantCustomBehavior::Hide)
-                                } else if 
+                                } else if
                                     anno.constify_enum_variant() {
                                     Some(EnumVariantCustomBehavior::Constify)
                                 } else {
diff --git a/src/ir/layout.rs b/src/ir/layout.rs
index 03d43b5..3837926 100644
--- a/src/ir/layout.rs
+++ b/src/ir/layout.rs
@@ -3,10 +3,10 @@
 use super::context::BindgenContext;
 use super::derive::{CanDeriveCopy, CanDeriveDebug, CanDeriveDefault};
 use super::ty::RUST_DERIVE_IN_ARRAY_LIMIT;
-use std::cmp;
+use std::{cmp, mem};
 
 /// A type that represents the struct layout of a type.
-#[derive(Debug, Clone, Copy)]
+#[derive(Debug, Clone, Copy, PartialEq)]
 pub struct Layout {
     /// The size (in bytes) of this layout.
     pub size: usize,
@@ -16,6 +16,13 @@
     pub packed: bool,
 }
 
+#[test]
+fn test_layout_for_size() {
+    let ptr_size = mem::size_of::<*mut ()>();
+    assert_eq!(Layout::for_size(ptr_size), Layout::new(ptr_size, ptr_size));
+    assert_eq!(Layout::for_size(3 * ptr_size), Layout::new(3 * ptr_size, ptr_size));
+}
+
 impl Layout {
     /// Construct a new `Layout` with the given `size` and `align`. It is not
     /// packed.
@@ -27,6 +34,20 @@
         }
     }
 
+    /// Creates a non-packed layout for a given size, trying to use the maximum
+    /// alignment possible.
+    pub fn for_size(size: usize) -> Self {
+        let mut next_align = 2;
+        while size % next_align == 0 && next_align <= 2 * mem::size_of::<*mut ()>() {
+            next_align *= 2;
+        }
+        Layout {
+            size: size,
+            align: next_align / 2,
+            packed: false,
+        }
+    }
+
     /// Is this a zero-sized layout?
     pub fn is_zero(&self) -> bool {
         self.size == 0 && self.align == 0
diff --git a/src/ir/ty.rs b/src/ir/ty.rs
index 332ad23..c3ec403 100644
--- a/src/ir/ty.rs
+++ b/src/ir/ty.rs
@@ -382,41 +382,8 @@
             _ => false,
         }
     }
-
-    /// If this type has a known size, return it (in bytes).
-    pub fn calc_size(&self, ctx: &BindgenContext) -> Option<usize> {
-        match self.kind {
-            TypeKind::Comp(ref ci) => {
-                ci.calc_layout(ctx).map(|layout| layout.size)
-            }
-            TypeKind::Enum(ref enum_ty) => {
-                enum_ty.calc_layout(ctx).map(|layout| layout.size)
-            }
-            TypeKind::Int(int_kind) => int_kind.known_size(),
-            TypeKind::Float(float_kind) => Some(float_kind.known_size()),
-            TypeKind::Complex(float_kind) => Some(float_kind.known_size() * 2),
-            TypeKind::Reference(..) |
-            TypeKind::NullPtr |
-            TypeKind::Pointer(..) |
-            TypeKind::BlockPointer |
-            TypeKind::Function(..) |
-            TypeKind::ObjCInterface(..) => Some(mem::size_of::<*mut ()>()),
-            TypeKind::ResolvedTypeRef(inner) |
-            TypeKind::Alias(inner) |
-            TypeKind::TemplateAlias(inner, _) |
-            TypeKind::TemplateInstantiation(inner, _) => {
-                ctx.resolve_type(inner).calc_size(ctx)
-            }
-            TypeKind::Array(inner, len) => {
-                ctx.resolve_type(inner)
-                    .layout(ctx)
-                    .map(|layout| layout.size * len)
-            }
-            TypeKind::Void | TypeKind::Named => None,
-            TypeKind::UnresolvedTypeRef(..) => unreachable!(),
-        }
-    }
 }
+
 #[test]
 fn is_invalid_named_type_valid() {
     let ty = Type::new(Some("foo".into()), None, TypeKind::Named, false);
diff --git a/tests/expectations/tests/bitfield_align.rs b/tests/expectations/tests/bitfield_align.rs
new file mode 100644
index 0000000..ffc170b
--- /dev/null
+++ b/tests/expectations/tests/bitfield_align.rs
@@ -0,0 +1,114 @@
+/* automatically generated by rust-bindgen */
+
+
+#![allow(non_snake_case)]
+
+
+#[repr(C)]
+#[derive(Debug, Default, Copy)]
+pub struct A {
+    pub x: ::std::os::raw::c_uchar,
+    pub _bitfield_1: [u8; 2usize],
+    pub y: ::std::os::raw::c_uchar,
+    pub __bindgen_align: [u32; 0usize],
+}
+#[test]
+fn bindgen_test_layout_A() {
+    assert_eq!(::std::mem::size_of::<A>() , 4usize , concat ! (
+               "Size of: " , stringify ! ( A ) ));
+    assert_eq! (::std::mem::align_of::<A>() , 4usize , concat ! (
+                "Alignment of " , stringify ! ( A ) ));
+    assert_eq! (unsafe { & ( * ( 0 as * const A ) ) . x as * const _ as usize
+                } , 0usize , concat ! (
+                "Alignment of field: " , stringify ! ( A ) , "::" , stringify
+                ! ( x ) ));
+    assert_eq! (unsafe { & ( * ( 0 as * const A ) ) . y as * const _ as usize
+                } , 3usize , concat ! (
+                "Alignment of field: " , stringify ! ( A ) , "::" , stringify
+                ! ( y ) ));
+}
+impl Clone for A {
+    fn clone(&self) -> Self { *self }
+}
+#[repr(C)]
+#[derive(Debug, Default, Copy)]
+pub struct B {
+    pub _bitfield_1: u32,
+    pub __bindgen_align: [u32; 0usize],
+}
+#[test]
+fn bindgen_test_layout_B() {
+    assert_eq!(::std::mem::size_of::<B>() , 4usize , concat ! (
+               "Size of: " , stringify ! ( B ) ));
+    assert_eq! (::std::mem::align_of::<B>() , 4usize , concat ! (
+                "Alignment of " , stringify ! ( B ) ));
+}
+impl Clone for B {
+    fn clone(&self) -> Self { *self }
+}
+#[repr(C)]
+#[derive(Debug, Default, Copy)]
+pub struct C {
+    pub x: ::std::os::raw::c_uchar,
+    pub _bitfield_1: u8,
+    pub baz: ::std::os::raw::c_uint,
+}
+#[test]
+fn bindgen_test_layout_C() {
+    assert_eq!(::std::mem::size_of::<C>() , 8usize , concat ! (
+               "Size of: " , stringify ! ( C ) ));
+    assert_eq! (::std::mem::align_of::<C>() , 4usize , concat ! (
+                "Alignment of " , stringify ! ( C ) ));
+    assert_eq! (unsafe { & ( * ( 0 as * const C ) ) . x as * const _ as usize
+                } , 0usize , concat ! (
+                "Alignment of field: " , stringify ! ( C ) , "::" , stringify
+                ! ( x ) ));
+    assert_eq! (unsafe {
+                & ( * ( 0 as * const C ) ) . baz as * const _ as usize } ,
+                4usize , concat ! (
+                "Alignment of field: " , stringify ! ( C ) , "::" , stringify
+                ! ( baz ) ));
+}
+impl Clone for C {
+    fn clone(&self) -> Self { *self }
+}
+#[repr(C)]
+#[derive(Debug, Default, Copy)]
+pub struct Date1 {
+    pub _bitfield_1: [u8; 2usize],
+    pub _bitfield_2: u8,
+    pub __bindgen_align: [u16; 0usize],
+}
+#[test]
+fn bindgen_test_layout_Date1() {
+    assert_eq!(::std::mem::size_of::<Date1>() , 4usize , concat ! (
+               "Size of: " , stringify ! ( Date1 ) ));
+    assert_eq! (::std::mem::align_of::<Date1>() , 2usize , concat ! (
+                "Alignment of " , stringify ! ( Date1 ) ));
+}
+impl Clone for Date1 {
+    fn clone(&self) -> Self { *self }
+}
+#[repr(C)]
+#[derive(Debug, Default, Copy)]
+pub struct Date2 {
+    pub _bitfield_1: [u8; 2usize],
+    pub _bitfield_2: u8,
+    pub byte: ::std::os::raw::c_uchar,
+    pub __bindgen_align: [u16; 0usize],
+}
+#[test]
+fn bindgen_test_layout_Date2() {
+    assert_eq!(::std::mem::size_of::<Date2>() , 4usize , concat ! (
+               "Size of: " , stringify ! ( Date2 ) ));
+    assert_eq! (::std::mem::align_of::<Date2>() , 2usize , concat ! (
+                "Alignment of " , stringify ! ( Date2 ) ));
+    assert_eq! (unsafe {
+                & ( * ( 0 as * const Date2 ) ) . byte as * const _ as usize }
+                , 3usize , concat ! (
+                "Alignment of field: " , stringify ! ( Date2 ) , "::" ,
+                stringify ! ( byte ) ));
+}
+impl Clone for Date2 {
+    fn clone(&self) -> Self { *self }
+}
diff --git a/tests/expectations/tests/bitfield_method_mangling.rs b/tests/expectations/tests/bitfield_method_mangling.rs
index 0a6c9fd..f21b208 100644
--- a/tests/expectations/tests/bitfield_method_mangling.rs
+++ b/tests/expectations/tests/bitfield_method_mangling.rs
@@ -8,6 +8,7 @@
 #[derive(Debug, Default, Copy)]
 pub struct mach_msg_type_descriptor_t {
     pub _bitfield_1: u32,
+    pub __bindgen_align: [u32; 0usize],
 }
 #[test]
 fn bindgen_test_layout_mach_msg_type_descriptor_t() {
@@ -22,32 +23,3 @@
 impl Clone for mach_msg_type_descriptor_t {
     fn clone(&self) -> Self { *self }
 }
-impl mach_msg_type_descriptor_t {
-    #[inline]
-    pub fn pad3(&self) -> ::std::os::raw::c_uint {
-        unsafe {
-            ::std::mem::transmute(((self._bitfield_1 & (16777215usize as u32))
-                                       >> 0u32) as u32)
-        }
-    }
-    #[inline]
-    pub fn set_pad3(&mut self, val: ::std::os::raw::c_uint) {
-        self._bitfield_1 &= !(16777215usize as u32);
-        self._bitfield_1 |=
-            ((val as u32 as u32) << 0u32) & (16777215usize as u32);
-    }
-    #[inline]
-    pub fn type_(&self) -> ::std::os::raw::c_uint {
-        unsafe {
-            ::std::mem::transmute(((self._bitfield_1 &
-                                        (4278190080usize as u32)) >> 24u32) as
-                                      u32)
-        }
-    }
-    #[inline]
-    pub fn set_type(&mut self, val: ::std::os::raw::c_uint) {
-        self._bitfield_1 &= !(4278190080usize as u32);
-        self._bitfield_1 |=
-            ((val as u32 as u32) << 24u32) & (4278190080usize as u32);
-    }
-}
diff --git a/tests/expectations/tests/jsval_layout_opaque.rs b/tests/expectations/tests/jsval_layout_opaque.rs
index 848286e..eb5306d 100644
--- a/tests/expectations/tests/jsval_layout_opaque.rs
+++ b/tests/expectations/tests/jsval_layout_opaque.rs
@@ -111,6 +111,7 @@
 #[derive(Debug, Copy)]
 pub struct jsval_layout__bindgen_ty_1 {
     pub _bitfield_1: u64,
+    pub __bindgen_align: [u64; 0usize],
 }
 #[test]
 fn bindgen_test_layout_jsval_layout__bindgen_ty_1() {
@@ -128,37 +129,6 @@
 impl Default for jsval_layout__bindgen_ty_1 {
     fn default() -> Self { unsafe { ::std::mem::zeroed() } }
 }
-impl jsval_layout__bindgen_ty_1 {
-    #[inline]
-    pub fn payload47(&self) -> u64 {
-        unsafe {
-            ::std::mem::transmute(((self._bitfield_1 &
-                                        (140737488355327usize as u64)) >>
-                                       0u32) as u64)
-        }
-    }
-    #[inline]
-    pub fn set_payload47(&mut self, val: u64) {
-        self._bitfield_1 &= !(140737488355327usize as u64);
-        self._bitfield_1 |=
-            ((val as u64 as u64) << 0u32) & (140737488355327usize as u64);
-    }
-    #[inline]
-    pub fn tag(&self) -> JSValueTag {
-        unsafe {
-            ::std::mem::transmute(((self._bitfield_1 &
-                                        (18446603336221196288usize as u64)) >>
-                                       47u32) as u32)
-        }
-    }
-    #[inline]
-    pub fn set_tag(&mut self, val: JSValueTag) {
-        self._bitfield_1 &= !(18446603336221196288usize as u64);
-        self._bitfield_1 |=
-            ((val as u32 as u64) << 47u32) &
-                (18446603336221196288usize as u64);
-    }
-}
 #[repr(C)]
 #[derive(Debug, Default, Copy)]
 pub struct jsval_layout__bindgen_ty_2 {
diff --git a/tests/expectations/tests/layout_align.rs b/tests/expectations/tests/layout_align.rs
index a21fa4d..9085480 100644
--- a/tests/expectations/tests/layout_align.rs
+++ b/tests/expectations/tests/layout_align.rs
@@ -71,6 +71,7 @@
     /**< ETH_SPEED_NUM_ */
     pub link_speed: u32,
     pub _bitfield_1: u8,
+    pub __bindgen_padding_0: [u8; 3usize],
     pub __bindgen_align: [u64; 0usize],
 }
 #[test]
@@ -88,41 +89,3 @@
 impl Clone for rte_eth_link {
     fn clone(&self) -> Self { *self }
 }
-impl rte_eth_link {
-    #[inline]
-    pub fn link_duplex(&self) -> u16 {
-        unsafe {
-            ::std::mem::transmute(((self._bitfield_1 & (1usize as u8)) >>
-                                       0u32) as u16)
-        }
-    }
-    #[inline]
-    pub fn set_link_duplex(&mut self, val: u16) {
-        self._bitfield_1 &= !(1usize as u8);
-        self._bitfield_1 |= ((val as u16 as u8) << 0u32) & (1usize as u8);
-    }
-    #[inline]
-    pub fn link_autoneg(&self) -> u16 {
-        unsafe {
-            ::std::mem::transmute(((self._bitfield_1 & (2usize as u8)) >>
-                                       1u32) as u16)
-        }
-    }
-    #[inline]
-    pub fn set_link_autoneg(&mut self, val: u16) {
-        self._bitfield_1 &= !(2usize as u8);
-        self._bitfield_1 |= ((val as u16 as u8) << 1u32) & (2usize as u8);
-    }
-    #[inline]
-    pub fn link_status(&self) -> u16 {
-        unsafe {
-            ::std::mem::transmute(((self._bitfield_1 & (4usize as u8)) >>
-                                       2u32) as u16)
-        }
-    }
-    #[inline]
-    pub fn set_link_status(&mut self, val: u16) {
-        self._bitfield_1 &= !(4usize as u8);
-        self._bitfield_1 |= ((val as u16 as u8) << 2u32) & (4usize as u8);
-    }
-}
diff --git a/tests/expectations/tests/layout_eth_conf.rs b/tests/expectations/tests/layout_eth_conf.rs
index 16788d0..ae46f5c 100644
--- a/tests/expectations/tests/layout_eth_conf.rs
+++ b/tests/expectations/tests/layout_eth_conf.rs
@@ -88,7 +88,7 @@
     pub max_rx_pkt_len: u32,
     /**< hdr buf size (header_split enabled).*/
     pub split_hdr_size: u16,
-    pub _bitfield_1: u16,
+    pub _bitfield_1: [u8; 2usize],
 }
 #[test]
 fn bindgen_test_layout_rte_eth_rxmode() {
@@ -118,116 +118,6 @@
 impl Default for rte_eth_rxmode {
     fn default() -> Self { unsafe { ::std::mem::zeroed() } }
 }
-impl rte_eth_rxmode {
-    #[inline]
-    pub fn header_split(&self) -> u16 {
-        unsafe {
-            ::std::mem::transmute(((self._bitfield_1 & (1usize as u16)) >>
-                                       0u32) as u16)
-        }
-    }
-    #[inline]
-    pub fn set_header_split(&mut self, val: u16) {
-        self._bitfield_1 &= !(1usize as u16);
-        self._bitfield_1 |= ((val as u16 as u16) << 0u32) & (1usize as u16);
-    }
-    #[inline]
-    pub fn hw_ip_checksum(&self) -> u16 {
-        unsafe {
-            ::std::mem::transmute(((self._bitfield_1 & (2usize as u16)) >>
-                                       1u32) as u16)
-        }
-    }
-    #[inline]
-    pub fn set_hw_ip_checksum(&mut self, val: u16) {
-        self._bitfield_1 &= !(2usize as u16);
-        self._bitfield_1 |= ((val as u16 as u16) << 1u32) & (2usize as u16);
-    }
-    #[inline]
-    pub fn hw_vlan_filter(&self) -> u16 {
-        unsafe {
-            ::std::mem::transmute(((self._bitfield_1 & (4usize as u16)) >>
-                                       2u32) as u16)
-        }
-    }
-    #[inline]
-    pub fn set_hw_vlan_filter(&mut self, val: u16) {
-        self._bitfield_1 &= !(4usize as u16);
-        self._bitfield_1 |= ((val as u16 as u16) << 2u32) & (4usize as u16);
-    }
-    #[inline]
-    pub fn hw_vlan_strip(&self) -> u16 {
-        unsafe {
-            ::std::mem::transmute(((self._bitfield_1 & (8usize as u16)) >>
-                                       3u32) as u16)
-        }
-    }
-    #[inline]
-    pub fn set_hw_vlan_strip(&mut self, val: u16) {
-        self._bitfield_1 &= !(8usize as u16);
-        self._bitfield_1 |= ((val as u16 as u16) << 3u32) & (8usize as u16);
-    }
-    #[inline]
-    pub fn hw_vlan_extend(&self) -> u16 {
-        unsafe {
-            ::std::mem::transmute(((self._bitfield_1 & (16usize as u16)) >>
-                                       4u32) as u16)
-        }
-    }
-    #[inline]
-    pub fn set_hw_vlan_extend(&mut self, val: u16) {
-        self._bitfield_1 &= !(16usize as u16);
-        self._bitfield_1 |= ((val as u16 as u16) << 4u32) & (16usize as u16);
-    }
-    #[inline]
-    pub fn jumbo_frame(&self) -> u16 {
-        unsafe {
-            ::std::mem::transmute(((self._bitfield_1 & (32usize as u16)) >>
-                                       5u32) as u16)
-        }
-    }
-    #[inline]
-    pub fn set_jumbo_frame(&mut self, val: u16) {
-        self._bitfield_1 &= !(32usize as u16);
-        self._bitfield_1 |= ((val as u16 as u16) << 5u32) & (32usize as u16);
-    }
-    #[inline]
-    pub fn hw_strip_crc(&self) -> u16 {
-        unsafe {
-            ::std::mem::transmute(((self._bitfield_1 & (64usize as u16)) >>
-                                       6u32) as u16)
-        }
-    }
-    #[inline]
-    pub fn set_hw_strip_crc(&mut self, val: u16) {
-        self._bitfield_1 &= !(64usize as u16);
-        self._bitfield_1 |= ((val as u16 as u16) << 6u32) & (64usize as u16);
-    }
-    #[inline]
-    pub fn enable_scatter(&self) -> u16 {
-        unsafe {
-            ::std::mem::transmute(((self._bitfield_1 & (128usize as u16)) >>
-                                       7u32) as u16)
-        }
-    }
-    #[inline]
-    pub fn set_enable_scatter(&mut self, val: u16) {
-        self._bitfield_1 &= !(128usize as u16);
-        self._bitfield_1 |= ((val as u16 as u16) << 7u32) & (128usize as u16);
-    }
-    #[inline]
-    pub fn enable_lro(&self) -> u16 {
-        unsafe {
-            ::std::mem::transmute(((self._bitfield_1 & (256usize as u16)) >>
-                                       8u32) as u16)
-        }
-    }
-    #[inline]
-    pub fn set_enable_lro(&mut self, val: u16) {
-        self._bitfield_1 &= !(256usize as u16);
-        self._bitfield_1 |= ((val as u16 as u16) << 8u32) & (256usize as u16);
-    }
-}
 #[repr(u32)]
 /**
  * A set of values to identify what method is to be used to transmit
@@ -250,6 +140,7 @@
     pub mq_mode: rte_eth_tx_mq_mode,
     pub pvid: u16,
     pub _bitfield_1: u8,
+    pub __bindgen_padding_0: u8,
 }
 #[test]
 fn bindgen_test_layout_rte_eth_txmode() {
@@ -274,44 +165,6 @@
 impl Default for rte_eth_txmode {
     fn default() -> Self { unsafe { ::std::mem::zeroed() } }
 }
-impl rte_eth_txmode {
-    #[inline]
-    pub fn hw_vlan_reject_tagged(&self) -> u8 {
-        unsafe {
-            ::std::mem::transmute(((self._bitfield_1 & (1usize as u8)) >>
-                                       0u32) as u8)
-        }
-    }
-    #[inline]
-    pub fn set_hw_vlan_reject_tagged(&mut self, val: u8) {
-        self._bitfield_1 &= !(1usize as u8);
-        self._bitfield_1 |= ((val as u8 as u8) << 0u32) & (1usize as u8);
-    }
-    #[inline]
-    pub fn hw_vlan_reject_untagged(&self) -> u8 {
-        unsafe {
-            ::std::mem::transmute(((self._bitfield_1 & (2usize as u8)) >>
-                                       1u32) as u8)
-        }
-    }
-    #[inline]
-    pub fn set_hw_vlan_reject_untagged(&mut self, val: u8) {
-        self._bitfield_1 &= !(2usize as u8);
-        self._bitfield_1 |= ((val as u8 as u8) << 1u32) & (2usize as u8);
-    }
-    #[inline]
-    pub fn hw_vlan_insert_pvid(&self) -> u8 {
-        unsafe {
-            ::std::mem::transmute(((self._bitfield_1 & (4usize as u8)) >>
-                                       2u32) as u8)
-        }
-    }
-    #[inline]
-    pub fn set_hw_vlan_insert_pvid(&mut self, val: u8) {
-        self._bitfield_1 &= !(4usize as u8);
-        self._bitfield_1 |= ((val as u8 as u8) << 2u32) & (4usize as u8);
-    }
-}
 /**
  * A structure used to configure the Receive Side Scaling (RSS) feature
  * of an Ethernet port.
diff --git a/tests/expectations/tests/layout_mbuf.rs b/tests/expectations/tests/layout_mbuf.rs
index 5732831..8ad13f1 100644
--- a/tests/expectations/tests/layout_mbuf.rs
+++ b/tests/expectations/tests/layout_mbuf.rs
@@ -158,7 +158,8 @@
 #[repr(C)]
 #[derive(Debug, Default, Copy)]
 pub struct rte_mbuf__bindgen_ty_2__bindgen_ty_1 {
-    pub _bitfield_1: u32,
+    pub _bitfield_1: [u8; 4usize],
+    pub __bindgen_align: [u32; 0usize],
 }
 #[test]
 fn bindgen_test_layout_rte_mbuf__bindgen_ty_2__bindgen_ty_1() {
@@ -174,98 +175,6 @@
 impl Clone for rte_mbuf__bindgen_ty_2__bindgen_ty_1 {
     fn clone(&self) -> Self { *self }
 }
-impl rte_mbuf__bindgen_ty_2__bindgen_ty_1 {
-    #[inline]
-    pub fn l2_type(&self) -> u32 {
-        unsafe {
-            ::std::mem::transmute(((self._bitfield_1 & (15usize as u32)) >>
-                                       0u32) as u32)
-        }
-    }
-    #[inline]
-    pub fn set_l2_type(&mut self, val: u32) {
-        self._bitfield_1 &= !(15usize as u32);
-        self._bitfield_1 |= ((val as u32 as u32) << 0u32) & (15usize as u32);
-    }
-    #[inline]
-    pub fn l3_type(&self) -> u32 {
-        unsafe {
-            ::std::mem::transmute(((self._bitfield_1 & (240usize as u32)) >>
-                                       4u32) as u32)
-        }
-    }
-    #[inline]
-    pub fn set_l3_type(&mut self, val: u32) {
-        self._bitfield_1 &= !(240usize as u32);
-        self._bitfield_1 |= ((val as u32 as u32) << 4u32) & (240usize as u32);
-    }
-    #[inline]
-    pub fn l4_type(&self) -> u32 {
-        unsafe {
-            ::std::mem::transmute(((self._bitfield_1 & (3840usize as u32)) >>
-                                       8u32) as u32)
-        }
-    }
-    #[inline]
-    pub fn set_l4_type(&mut self, val: u32) {
-        self._bitfield_1 &= !(3840usize as u32);
-        self._bitfield_1 |=
-            ((val as u32 as u32) << 8u32) & (3840usize as u32);
-    }
-    #[inline]
-    pub fn tun_type(&self) -> u32 {
-        unsafe {
-            ::std::mem::transmute(((self._bitfield_1 & (61440usize as u32)) >>
-                                       12u32) as u32)
-        }
-    }
-    #[inline]
-    pub fn set_tun_type(&mut self, val: u32) {
-        self._bitfield_1 &= !(61440usize as u32);
-        self._bitfield_1 |=
-            ((val as u32 as u32) << 12u32) & (61440usize as u32);
-    }
-    #[inline]
-    pub fn inner_l2_type(&self) -> u32 {
-        unsafe {
-            ::std::mem::transmute(((self._bitfield_1 & (983040usize as u32))
-                                       >> 16u32) as u32)
-        }
-    }
-    #[inline]
-    pub fn set_inner_l2_type(&mut self, val: u32) {
-        self._bitfield_1 &= !(983040usize as u32);
-        self._bitfield_1 |=
-            ((val as u32 as u32) << 16u32) & (983040usize as u32);
-    }
-    #[inline]
-    pub fn inner_l3_type(&self) -> u32 {
-        unsafe {
-            ::std::mem::transmute(((self._bitfield_1 & (15728640usize as u32))
-                                       >> 20u32) as u32)
-        }
-    }
-    #[inline]
-    pub fn set_inner_l3_type(&mut self, val: u32) {
-        self._bitfield_1 &= !(15728640usize as u32);
-        self._bitfield_1 |=
-            ((val as u32 as u32) << 20u32) & (15728640usize as u32);
-    }
-    #[inline]
-    pub fn inner_l4_type(&self) -> u32 {
-        unsafe {
-            ::std::mem::transmute(((self._bitfield_1 &
-                                        (251658240usize as u32)) >> 24u32) as
-                                      u32)
-        }
-    }
-    #[inline]
-    pub fn set_inner_l4_type(&mut self, val: u32) {
-        self._bitfield_1 &= !(251658240usize as u32);
-        self._bitfield_1 |=
-            ((val as u32 as u32) << 24u32) & (251658240usize as u32);
-    }
-}
 #[test]
 fn bindgen_test_layout_rte_mbuf__bindgen_ty_2() {
     assert_eq!(::std::mem::size_of::<rte_mbuf__bindgen_ty_2>() , 4usize ,
@@ -499,7 +408,8 @@
 #[repr(C)]
 #[derive(Debug, Default, Copy)]
 pub struct rte_mbuf__bindgen_ty_5__bindgen_ty_1 {
-    pub _bitfield_1: u64,
+    pub _bitfield_1: [u16; 4usize],
+    pub __bindgen_align: [u64; 0usize],
 }
 #[test]
 fn bindgen_test_layout_rte_mbuf__bindgen_ty_5__bindgen_ty_1() {
@@ -515,88 +425,6 @@
 impl Clone for rte_mbuf__bindgen_ty_5__bindgen_ty_1 {
     fn clone(&self) -> Self { *self }
 }
-impl rte_mbuf__bindgen_ty_5__bindgen_ty_1 {
-    #[inline]
-    pub fn l2_len(&self) -> u64 {
-        unsafe {
-            ::std::mem::transmute(((self._bitfield_1 & (127usize as u64)) >>
-                                       0u32) as u64)
-        }
-    }
-    #[inline]
-    pub fn set_l2_len(&mut self, val: u64) {
-        self._bitfield_1 &= !(127usize as u64);
-        self._bitfield_1 |= ((val as u64 as u64) << 0u32) & (127usize as u64);
-    }
-    #[inline]
-    pub fn l3_len(&self) -> u64 {
-        unsafe {
-            ::std::mem::transmute(((self._bitfield_1 & (65408usize as u64)) >>
-                                       7u32) as u64)
-        }
-    }
-    #[inline]
-    pub fn set_l3_len(&mut self, val: u64) {
-        self._bitfield_1 &= !(65408usize as u64);
-        self._bitfield_1 |=
-            ((val as u64 as u64) << 7u32) & (65408usize as u64);
-    }
-    #[inline]
-    pub fn l4_len(&self) -> u64 {
-        unsafe {
-            ::std::mem::transmute(((self._bitfield_1 & (16711680usize as u64))
-                                       >> 16u32) as u64)
-        }
-    }
-    #[inline]
-    pub fn set_l4_len(&mut self, val: u64) {
-        self._bitfield_1 &= !(16711680usize as u64);
-        self._bitfield_1 |=
-            ((val as u64 as u64) << 16u32) & (16711680usize as u64);
-    }
-    #[inline]
-    pub fn tso_segsz(&self) -> u64 {
-        unsafe {
-            ::std::mem::transmute(((self._bitfield_1 &
-                                        (1099494850560usize as u64)) >> 24u32)
-                                      as u64)
-        }
-    }
-    #[inline]
-    pub fn set_tso_segsz(&mut self, val: u64) {
-        self._bitfield_1 &= !(1099494850560usize as u64);
-        self._bitfield_1 |=
-            ((val as u64 as u64) << 24u32) & (1099494850560usize as u64);
-    }
-    #[inline]
-    pub fn outer_l3_len(&self) -> u64 {
-        unsafe {
-            ::std::mem::transmute(((self._bitfield_1 &
-                                        (561850441793536usize as u64)) >>
-                                       40u32) as u64)
-        }
-    }
-    #[inline]
-    pub fn set_outer_l3_len(&mut self, val: u64) {
-        self._bitfield_1 &= !(561850441793536usize as u64);
-        self._bitfield_1 |=
-            ((val as u64 as u64) << 40u32) & (561850441793536usize as u64);
-    }
-    #[inline]
-    pub fn outer_l2_len(&self) -> u64 {
-        unsafe {
-            ::std::mem::transmute(((self._bitfield_1 &
-                                        (71494644084506624usize as u64)) >>
-                                       49u32) as u64)
-        }
-    }
-    #[inline]
-    pub fn set_outer_l2_len(&mut self, val: u64) {
-        self._bitfield_1 &= !(71494644084506624usize as u64);
-        self._bitfield_1 |=
-            ((val as u64 as u64) << 49u32) & (71494644084506624usize as u64);
-    }
-}
 #[test]
 fn bindgen_test_layout_rte_mbuf__bindgen_ty_5() {
     assert_eq!(::std::mem::size_of::<rte_mbuf__bindgen_ty_5>() , 8usize ,
diff --git a/tests/expectations/tests/only_bitfields.rs b/tests/expectations/tests/only_bitfields.rs
index 9252097..643725d 100644
--- a/tests/expectations/tests/only_bitfields.rs
+++ b/tests/expectations/tests/only_bitfields.rs
@@ -8,6 +8,7 @@
 #[derive(Debug, Default, Copy)]
 pub struct C {
     pub _bitfield_1: u8,
+    pub __bindgen_align: [u8; 0usize],
 }
 #[test]
 fn bindgen_test_layout_C() {
@@ -19,29 +20,3 @@
 impl Clone for C {
     fn clone(&self) -> Self { *self }
 }
-impl C {
-    #[inline]
-    pub fn a(&self) -> bool {
-        unsafe {
-            ::std::mem::transmute(((self._bitfield_1 & (1usize as u8)) >>
-                                       0u32) as u8)
-        }
-    }
-    #[inline]
-    pub fn set_a(&mut self, val: bool) {
-        self._bitfield_1 &= !(1usize as u8);
-        self._bitfield_1 |= ((val as u8 as u8) << 0u32) & (1usize as u8);
-    }
-    #[inline]
-    pub fn b(&self) -> bool {
-        unsafe {
-            ::std::mem::transmute(((self._bitfield_1 & (254usize as u8)) >>
-                                       1u32) as u8)
-        }
-    }
-    #[inline]
-    pub fn set_b(&mut self, val: bool) {
-        self._bitfield_1 &= !(254usize as u8);
-        self._bitfield_1 |= ((val as u8 as u8) << 1u32) & (254usize as u8);
-    }
-}
diff --git a/tests/expectations/tests/struct_with_bitfields.rs b/tests/expectations/tests/struct_with_bitfields.rs
index 861ad66..2f9ba42 100644
--- a/tests/expectations/tests/struct_with_bitfields.rs
+++ b/tests/expectations/tests/struct_with_bitfields.rs
@@ -27,103 +27,3 @@
 impl Clone for bitfield {
     fn clone(&self) -> Self { *self }
 }
-impl bitfield {
-    #[inline]
-    pub fn a(&self) -> ::std::os::raw::c_ushort {
-        unsafe {
-            ::std::mem::transmute(((self._bitfield_1 & (1usize as u8)) >>
-                                       0u32) as u16)
-        }
-    }
-    #[inline]
-    pub fn set_a(&mut self, val: ::std::os::raw::c_ushort) {
-        self._bitfield_1 &= !(1usize as u8);
-        self._bitfield_1 |= ((val as u16 as u8) << 0u32) & (1usize as u8);
-    }
-    #[inline]
-    pub fn b(&self) -> ::std::os::raw::c_ushort {
-        unsafe {
-            ::std::mem::transmute(((self._bitfield_1 & (2usize as u8)) >>
-                                       1u32) as u16)
-        }
-    }
-    #[inline]
-    pub fn set_b(&mut self, val: ::std::os::raw::c_ushort) {
-        self._bitfield_1 &= !(2usize as u8);
-        self._bitfield_1 |= ((val as u16 as u8) << 1u32) & (2usize as u8);
-    }
-    #[inline]
-    pub fn c(&self) -> ::std::os::raw::c_ushort {
-        unsafe {
-            ::std::mem::transmute(((self._bitfield_1 & (4usize as u8)) >>
-                                       2u32) as u16)
-        }
-    }
-    #[inline]
-    pub fn set_c(&mut self, val: ::std::os::raw::c_ushort) {
-        self._bitfield_1 &= !(4usize as u8);
-        self._bitfield_1 |= ((val as u16 as u8) << 2u32) & (4usize as u8);
-    }
-    #[inline]
-    pub fn at_offset_3(&self) -> ::std::os::raw::c_ushort {
-        unsafe {
-            ::std::mem::transmute(((self._bitfield_1 & (8usize as u8)) >>
-                                       3u32) as u16)
-        }
-    }
-    #[inline]
-    pub fn set_at_offset_3(&mut self, val: ::std::os::raw::c_ushort) {
-        self._bitfield_1 &= !(8usize as u8);
-        self._bitfield_1 |= ((val as u16 as u8) << 3u32) & (8usize as u8);
-    }
-    #[inline]
-    pub fn at_offset_4(&self) -> ::std::os::raw::c_ushort {
-        unsafe {
-            ::std::mem::transmute(((self._bitfield_1 & (48usize as u8)) >>
-                                       4u32) as u16)
-        }
-    }
-    #[inline]
-    pub fn set_at_offset_4(&mut self, val: ::std::os::raw::c_ushort) {
-        self._bitfield_1 &= !(48usize as u8);
-        self._bitfield_1 |= ((val as u16 as u8) << 4u32) & (48usize as u8);
-    }
-    #[inline]
-    pub fn d(&self) -> ::std::os::raw::c_ushort {
-        unsafe {
-            ::std::mem::transmute(((self._bitfield_1 & (192usize as u8)) >>
-                                       6u32) as u16)
-        }
-    }
-    #[inline]
-    pub fn set_d(&mut self, val: ::std::os::raw::c_ushort) {
-        self._bitfield_1 &= !(192usize as u8);
-        self._bitfield_1 |= ((val as u16 as u8) << 6u32) & (192usize as u8);
-    }
-    #[inline]
-    pub fn f(&self) -> ::std::os::raw::c_uint {
-        unsafe {
-            ::std::mem::transmute(((self._bitfield_2 & (3usize as u8)) >>
-                                       0u32) as u32)
-        }
-    }
-    #[inline]
-    pub fn set_f(&mut self, val: ::std::os::raw::c_uint) {
-        self._bitfield_2 &= !(3usize as u8);
-        self._bitfield_2 |= ((val as u32 as u8) << 0u32) & (3usize as u8);
-    }
-    #[inline]
-    pub fn g(&self) -> ::std::os::raw::c_uint {
-        unsafe {
-            ::std::mem::transmute(((self._bitfield_3 &
-                                        (4294967295usize as u32)) >> 0u32) as
-                                      u32)
-        }
-    }
-    #[inline]
-    pub fn set_g(&mut self, val: ::std::os::raw::c_uint) {
-        self._bitfield_3 &= !(4294967295usize as u32);
-        self._bitfield_3 |=
-            ((val as u32 as u32) << 0u32) & (4294967295usize as u32);
-    }
-}
diff --git a/tests/expectations/tests/union_with_anon_struct_bitfield.rs b/tests/expectations/tests/union_with_anon_struct_bitfield.rs
index d14a38b..f102117 100644
--- a/tests/expectations/tests/union_with_anon_struct_bitfield.rs
+++ b/tests/expectations/tests/union_with_anon_struct_bitfield.rs
@@ -39,6 +39,7 @@
 #[derive(Debug, Default, Copy)]
 pub struct foo__bindgen_ty_1 {
     pub _bitfield_1: u32,
+    pub __bindgen_align: [u32; 0usize],
 }
 #[test]
 fn bindgen_test_layout_foo__bindgen_ty_1() {
@@ -50,34 +51,6 @@
 impl Clone for foo__bindgen_ty_1 {
     fn clone(&self) -> Self { *self }
 }
-impl foo__bindgen_ty_1 {
-    #[inline]
-    pub fn b(&self) -> ::std::os::raw::c_int {
-        unsafe {
-            ::std::mem::transmute(((self._bitfield_1 & (127usize as u32)) >>
-                                       0u32) as u32)
-        }
-    }
-    #[inline]
-    pub fn set_b(&mut self, val: ::std::os::raw::c_int) {
-        self._bitfield_1 &= !(127usize as u32);
-        self._bitfield_1 |= ((val as u32 as u32) << 0u32) & (127usize as u32);
-    }
-    #[inline]
-    pub fn c(&self) -> ::std::os::raw::c_int {
-        unsafe {
-            ::std::mem::transmute(((self._bitfield_1 &
-                                        (4294967168usize as u32)) >> 7u32) as
-                                      u32)
-        }
-    }
-    #[inline]
-    pub fn set_c(&mut self, val: ::std::os::raw::c_int) {
-        self._bitfield_1 &= !(4294967168usize as u32);
-        self._bitfield_1 |=
-            ((val as u32 as u32) << 7u32) & (4294967168usize as u32);
-    }
-}
 #[test]
 fn bindgen_test_layout_foo() {
     assert_eq!(::std::mem::size_of::<foo>() , 4usize , concat ! (
diff --git a/tests/expectations/tests/unknown_attr.rs b/tests/expectations/tests/unknown_attr.rs
index 2c50c36..23d9ff7 100644
--- a/tests/expectations/tests/unknown_attr.rs
+++ b/tests/expectations/tests/unknown_attr.rs
@@ -9,7 +9,7 @@
 pub struct max_align_t {
     pub __clang_max_align_nonce1: ::std::os::raw::c_longlong,
     pub __bindgen_padding_0: u64,
-    pub __clang_max_align_nonce2: f64,
+    pub __clang_max_align_nonce2: ::std::os::raw::c_longlong,
     pub __bindgen_padding_1: u64,
 }
 #[test]
diff --git a/tests/expectations/tests/weird_bitfields.rs b/tests/expectations/tests/weird_bitfields.rs
index a2841e3..466904e 100644
--- a/tests/expectations/tests/weird_bitfields.rs
+++ b/tests/expectations/tests/weird_bitfields.rs
@@ -15,7 +15,7 @@
 #[derive(Debug, Copy)]
 pub struct Weird {
     pub mStrokeDasharrayLength: ::std::os::raw::c_uint,
-    pub _bitfield_1: u32,
+    pub _bitfield_1: [u16; 2usize],
     pub mClipRule: ::std::os::raw::c_uchar,
     pub mColorInterpolation: ::std::os::raw::c_uchar,
     pub mColorInterpolationFilters: ::std::os::raw::c_uchar,
@@ -27,7 +27,8 @@
     pub mStrokeLinejoin: ::std::os::raw::c_uchar,
     pub mTextAnchor: ::std::os::raw::c_uchar,
     pub mTextRendering: ::std::os::raw::c_uchar,
-    pub _bitfield_2: u16,
+    pub _bitfield_2: u8,
+    pub _bitfield_3: u8,
 }
 #[test]
 fn bindgen_test_layout_Weird() {
@@ -102,92 +103,3 @@
 impl Default for Weird {
     fn default() -> Self { unsafe { ::std::mem::zeroed() } }
 }
-impl Weird {
-    #[inline]
-    pub fn bitTest(&self) -> ::std::os::raw::c_uint {
-        unsafe {
-            ::std::mem::transmute(((self._bitfield_1 & (65535usize as u32)) >>
-                                       0u32) as u32)
-        }
-    }
-    #[inline]
-    pub fn set_bitTest(&mut self, val: ::std::os::raw::c_uint) {
-        self._bitfield_1 &= !(65535usize as u32);
-        self._bitfield_1 |=
-            ((val as u32 as u32) << 0u32) & (65535usize as u32);
-    }
-    #[inline]
-    pub fn bitTest2(&self) -> ::std::os::raw::c_uint {
-        unsafe {
-            ::std::mem::transmute(((self._bitfield_1 &
-                                        (2147418112usize as u32)) >> 16u32) as
-                                      u32)
-        }
-    }
-    #[inline]
-    pub fn set_bitTest2(&mut self, val: ::std::os::raw::c_uint) {
-        self._bitfield_1 &= !(2147418112usize as u32);
-        self._bitfield_1 |=
-            ((val as u32 as u32) << 16u32) & (2147418112usize as u32);
-    }
-    #[inline]
-    pub fn mFillOpacitySource(&self) -> nsStyleSVGOpacitySource {
-        unsafe {
-            ::std::mem::transmute(((self._bitfield_2 & (7usize as u16)) >>
-                                       0u32) as u32)
-        }
-    }
-    #[inline]
-    pub fn set_mFillOpacitySource(&mut self, val: nsStyleSVGOpacitySource) {
-        self._bitfield_2 &= !(7usize as u16);
-        self._bitfield_2 |= ((val as u32 as u16) << 0u32) & (7usize as u16);
-    }
-    #[inline]
-    pub fn mStrokeOpacitySource(&self) -> nsStyleSVGOpacitySource {
-        unsafe {
-            ::std::mem::transmute(((self._bitfield_2 & (56usize as u16)) >>
-                                       3u32) as u32)
-        }
-    }
-    #[inline]
-    pub fn set_mStrokeOpacitySource(&mut self, val: nsStyleSVGOpacitySource) {
-        self._bitfield_2 &= !(56usize as u16);
-        self._bitfield_2 |= ((val as u32 as u16) << 3u32) & (56usize as u16);
-    }
-    #[inline]
-    pub fn mStrokeDasharrayFromObject(&self) -> bool {
-        unsafe {
-            ::std::mem::transmute(((self._bitfield_2 & (64usize as u16)) >>
-                                       6u32) as u8)
-        }
-    }
-    #[inline]
-    pub fn set_mStrokeDasharrayFromObject(&mut self, val: bool) {
-        self._bitfield_2 &= !(64usize as u16);
-        self._bitfield_2 |= ((val as u8 as u16) << 6u32) & (64usize as u16);
-    }
-    #[inline]
-    pub fn mStrokeDashoffsetFromObject(&self) -> bool {
-        unsafe {
-            ::std::mem::transmute(((self._bitfield_2 & (128usize as u16)) >>
-                                       7u32) as u8)
-        }
-    }
-    #[inline]
-    pub fn set_mStrokeDashoffsetFromObject(&mut self, val: bool) {
-        self._bitfield_2 &= !(128usize as u16);
-        self._bitfield_2 |= ((val as u8 as u16) << 7u32) & (128usize as u16);
-    }
-    #[inline]
-    pub fn mStrokeWidthFromObject(&self) -> bool {
-        unsafe {
-            ::std::mem::transmute(((self._bitfield_2 & (256usize as u16)) >>
-                                       8u32) as u8)
-        }
-    }
-    #[inline]
-    pub fn set_mStrokeWidthFromObject(&mut self, val: bool) {
-        self._bitfield_2 &= !(256usize as u16);
-        self._bitfield_2 |= ((val as u8 as u16) << 8u32) & (256usize as u16);
-    }
-}
diff --git a/tests/headers/bitfield_align.h b/tests/headers/bitfield_align.h
new file mode 100644
index 0000000..82b5309
--- /dev/null
+++ b/tests/headers/bitfield_align.h
@@ -0,0 +1,41 @@
+struct A {
+  unsigned char x;
+  unsigned b1 : 1;
+  unsigned b2 : 1;
+  unsigned b3 : 1;
+  unsigned b4 : 1;
+  unsigned b5 : 1;
+  unsigned b6 : 1;
+  unsigned b7 : 1;
+  unsigned b8 : 1;
+  unsigned b9 : 1;
+  unsigned b10 : 1;
+  unsigned char y;
+};
+
+struct B {
+  unsigned foo : 31;
+  unsigned char bar : 1;
+};
+
+struct C {
+  unsigned char x;
+  unsigned b1 : 1;
+  unsigned b2 : 1;
+  unsigned baz;
+};
+
+struct Date1 {
+   unsigned short nWeekDay  : 3;    // 0..7   (3 bits)
+   unsigned short nMonthDay : 6;    // 0..31  (6 bits)
+   unsigned short nMonth    : 5;    // 0..12  (5 bits)
+   unsigned short nYear     : 8;    // 0..100 (8 bits)
+};
+
+struct Date2 {
+   unsigned short nWeekDay  : 3;    // 0..7   (3 bits)
+   unsigned short nMonthDay : 6;    // 0..31  (6 bits)
+   unsigned short nMonth    : 5;    // 0..12  (5 bits)
+   unsigned short nYear     : 8;    // 0..100 (8 bits)
+   unsigned char byte;
+};
diff --git a/tests/headers/unknown_attr.h b/tests/headers/unknown_attr.h
index f87e9f0..1e89fb1 100644
--- a/tests/headers/unknown_attr.h
+++ b/tests/headers/unknown_attr.h
@@ -1,6 +1,6 @@
 typedef struct {
   long long __clang_max_align_nonce1
       __attribute__((__aligned__(__alignof__(long long))));
-  long double __clang_max_align_nonce2
+  long long __clang_max_align_nonce2
       __attribute__((__aligned__(__alignof__(long double))));
 } max_align_t;