summaryrefslogtreecommitdiff
diff options
context:
space:
mode:
-rw-r--r--.gitignore4
-rw-r--r--CONTRIBUTING.md31
-rw-r--r--Cargo.lock2
-rw-r--r--Cargo.toml2
-rw-r--r--bindgen-integration/build.rs1
-rw-r--r--bindgen-integration/cpp/Test.cc25
-rw-r--r--bindgen-integration/cpp/Test.h30
-rwxr-xr-xbindgen-integration/src/lib.rs42
-rw-r--r--book/src/tutorial-3.md4
-rw-r--r--book/src/using-unions.md10
-rw-r--r--src/clang.rs72
-rw-r--r--src/codegen/mod.rs110
-rw-r--r--src/ir/comp.rs19
-rw-r--r--src/ir/context.rs209
-rw-r--r--src/ir/dot.rs9
-rw-r--r--src/ir/function.rs10
-rw-r--r--src/ir/item.rs22
-rw-r--r--src/ir/module.rs15
-rw-r--r--src/ir/template.rs14
-rw-r--r--src/ir/ty.rs14
-rw-r--r--src/ir/var.rs28
-rw-r--r--src/lib.rs8
-rw-r--r--src/options.rs10
-rw-r--r--tests/expectations/tests/anon_union.rs2
-rw-r--r--tests/expectations/tests/bitfield-32bit-overflow.rs1600
-rw-r--r--tests/expectations/tests/bitfield-method-same-name.rs35
-rw-r--r--tests/expectations/tests/bitfield_align.rs970
-rw-r--r--tests/expectations/tests/bitfield_align_2.rs68
-rw-r--r--tests/expectations/tests/bitfield_method_mangling.rs70
-rw-r--r--tests/expectations/tests/class_nested.rs2
-rw-r--r--tests/expectations/tests/class_with_dtor.rs2
-rw-r--r--tests/expectations/tests/crtp.rs4
-rw-r--r--tests/expectations/tests/default-template-parameter.rs2
-rw-r--r--tests/expectations/tests/enum_and_vtable_mangling.rs4
-rw-r--r--tests/expectations/tests/forward-declaration-autoptr.rs9
-rw-r--r--tests/expectations/tests/gen-constructors-neg.rs4
-rw-r--r--tests/expectations/tests/gen-destructors-neg.rs4
-rw-r--r--tests/expectations/tests/inner_template_self.rs9
-rw-r--r--tests/expectations/tests/issue-372.rs11
-rw-r--r--tests/expectations/tests/issue-569-non-type-template-params-causing-layout-test-failures.rs2
-rw-r--r--tests/expectations/tests/issue-573-layout-test-failures.rs8
-rw-r--r--tests/expectations/tests/issue-574-assertion-failure-in-codegen.rs8
-rw-r--r--tests/expectations/tests/issue-584-stylo-template-analysis-panic.rs8
-rw-r--r--tests/expectations/tests/issue-674-1.rs9
-rw-r--r--tests/expectations/tests/issue-674-2.rs20
-rw-r--r--tests/expectations/tests/issue-674-3.rs9
-rw-r--r--tests/expectations/tests/issue-691-template-parameter-virtual.rs2
-rw-r--r--tests/expectations/tests/issue-739-pointer-wide-bitfield.rs22
-rw-r--r--tests/expectations/tests/jsval_layout_opaque.rs68
-rw-r--r--tests/expectations/tests/layout_align.rs103
-rw-r--r--tests/expectations/tests/layout_eth_conf.rs408
-rw-r--r--tests/expectations/tests/layout_mbuf.rs442
-rw-r--r--tests/expectations/tests/libclang-3.8/issue-769-bad-instantiation-test.rs42
-rw-r--r--tests/expectations/tests/libclang-3.8/partial-specialization-and-inheritance.rs18
-rw-r--r--tests/expectations/tests/libclang-3.9/issue-769-bad-instantiation-test.rs42
-rw-r--r--tests/expectations/tests/libclang-3.9/partial-specialization-and-inheritance.rs18
-rw-r--r--tests/expectations/tests/libclang-4/issue-769-bad-instantiation-test.rs43
-rw-r--r--tests/expectations/tests/libclang-4/partial-specialization-and-inheritance.rs18
-rw-r--r--tests/expectations/tests/libclang-4/type_alias_template_specialized.rs11
-rw-r--r--tests/expectations/tests/macro-expr-uncommon-token.rs10
-rw-r--r--tests/expectations/tests/mangling-macos.rs9
-rw-r--r--tests/expectations/tests/mangling-win32.rs9
-rw-r--r--tests/expectations/tests/nested_vtable.rs5
-rw-r--r--tests/expectations/tests/non-type-params.rs20
-rw-r--r--tests/expectations/tests/only_bitfields.rs68
-rw-r--r--tests/expectations/tests/opaque_pointer.rs8
-rw-r--r--tests/expectations/tests/prepend-enum-constified-variant.rs10
-rw-r--r--tests/expectations/tests/ref_argument_array.rs6
-rw-r--r--tests/expectations/tests/replace_use.rs9
-rw-r--r--tests/expectations/tests/replaces_double.rs10
-rw-r--r--tests/expectations/tests/size_t_template.rs9
-rw-r--r--tests/expectations/tests/struct_with_bitfields.rs204
-rw-r--r--tests/expectations/tests/template-with-var.rs11
-rw-r--r--tests/expectations/tests/template.rs32
-rw-r--r--tests/expectations/tests/typeref.rs11
-rw-r--r--tests/expectations/tests/union_with_anon_struct_bitfield.rs68
-rw-r--r--tests/expectations/tests/virtual_dtor.rs4
-rw-r--r--tests/expectations/tests/virtual_overloaded.rs10
-rw-r--r--tests/expectations/tests/vtable_recursive_sig.rs4
-rw-r--r--tests/expectations/tests/weird_bitfields.rs240
-rw-r--r--tests/headers/bitfield-32bit-overflow.h36
-rw-r--r--tests/headers/bitfield_align.h16
-rw-r--r--tests/headers/class_nested.hpp2
-rw-r--r--tests/headers/enum_and_vtable_mangling.hpp2
-rw-r--r--tests/headers/issue-739-pointer-wide-bitfield.h8
-rw-r--r--tests/headers/issue-769-bad-instantiation-test.hpp11
-rw-r--r--tests/headers/jsval_layout_opaque.hpp2
-rw-r--r--tests/headers/macro-expr-uncommon-token.h7
-rw-r--r--tests/headers/mangling-macos.h3
-rw-r--r--tests/headers/mangling-win32.h3
-rw-r--r--tests/headers/only_bitfields.hpp1
-rw-r--r--tests/headers/prepend-enum-constified-variant.h6
-rw-r--r--tests/headers/struct_with_bitfields.h1
-rw-r--r--tests/headers/template-with-var.hpp7
-rw-r--r--tests/headers/template.hpp5
-rw-r--r--tests/headers/union_with_anon_struct_bitfield.h1
-rw-r--r--tests/headers/virtual_overloaded.hpp4
-rw-r--r--tests/headers/vtable_recursive_sig.hpp4
-rw-r--r--tests/headers/weird_bitfields.hpp1
-rwxr-xr-xtests/test-one.sh29
-rw-r--r--tests/tests.rs3
101 files changed, 4827 insertions, 870 deletions
diff --git a/.gitignore b/.gitignore
index 71a7df6d..906dcfee 100644
--- a/.gitignore
+++ b/.gitignore
@@ -4,3 +4,7 @@ target/
bindgen-integration/Cargo.lock
tests/expectations/Cargo.lock
#*#
+
+# Test script output
+ir.dot
+ir.png
diff --git a/CONTRIBUTING.md b/CONTRIBUTING.md
index bc5c883d..de5f709d 100644
--- a/CONTRIBUTING.md
+++ b/CONTRIBUTING.md
@@ -10,6 +10,7 @@ out to us in a GitHub issue, or stop by
- [Code of Conduct](#code-of-conduct)
- [Filing an Issue](#filing-an-issue)
+- [Looking to Start Contributing to `bindgen`?](#looking-to-start-contributing-to-bindgen)
- [Building](#building)
- [Testing](#testing)
- [Overview](#overview)
@@ -18,6 +19,7 @@ out to us in a GitHub issue, or stop by
- [Authoring New Tests](#authoring-new-tests)
- [Test Expectations and `libclang` Versions](#test-expectations-and-libclang-versions)
- [Automatic code formatting](#automatic-code-formatting)
+- [Pull Requests and Code Reviews](#pull-requests-and-code-reviews)
- [Generating Graphviz Dot Files](#generating-graphviz-dot-files)
- [Debug Logging](#debug-logging)
- [Using `creduce` to Minimize Test Cases](#using-creduce-to-minimize-test-cases)
@@ -37,12 +39,18 @@ We abide by the [Rust Code of Conduct][coc] and ask that you do as well.
Think you've found a bug? File an issue! To help us understand and reproduce the
issue, provide us with:
-* A (preferrably reduced) C/C++ header file that reproduces the issue
+* A (preferably reduced) C/C++ header file that reproduces the issue
* The `bindgen` flags used to reproduce the issue with the header file
* The expected `bindgen` output
* The actual `bindgen` output
* The [debugging logs](#logs) generated when running `bindgen` on this testcase
+## Looking to Start Contributing to `bindgen`?
+
+* [Issues labeled "easy"](https://github.com/servo/rust-bindgen/issues?q=is%3Aopen+is%3Aissue+label%3AE-easy)
+* [Issues labeled "less easy"](https://github.com/servo/rust-bindgen/issues?q=is%3Aopen+is%3Aissue+label%3AE-less-easy)
+* Still can't find something to work on? [Drop a comment here](https://github.com/servo/rust-bindgen/issues/747)
+
## Building
To build the `bindgen` library and the `bindgen` executable:
@@ -176,6 +184,27 @@ $ cargo fmt
The code style is described in the `rustfmt.toml` file in top level of the repo.
+## Pull Requests and Code Reviews
+
+Ensure that each commit stands alone, and passes tests. This enables better `git
+bisect`ing when needed. If your commits do not stand on their own, then rebase
+them on top of the latest master and squash them into a single commit.
+
+All pull requests undergo code review before merging. To request review, comment
+`r? @github_username_of_reviewer`. They we will respond with `r+` to approve the
+pull request, or may leave feedback and request changes to the pull request. Any
+changes should be squashed into the original commit.
+
+Unsure who to ask for review? Ask any of:
+
+* `@emilio`
+* `@fitzgen`
+
+More resources:
+
+* [Servo's GitHub Workflow](https://github.com/servo/servo/wiki/Github-workflow)
+* [Beginner's Guide to Rebasing and Squashing](https://github.com/servo/servo/wiki/Beginner's-guide-to-rebasing-and-squashing)
+
## Generating Graphviz Dot Files
We can generate [Graphviz](http://graphviz.org/pdf/dotguide.pdf) dot files from
diff --git a/Cargo.lock b/Cargo.lock
index 309b7dff..b88f8be1 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -1,6 +1,6 @@
[root]
name = "bindgen"
-version = "0.25.3"
+version = "0.26.1"
dependencies = [
"aster 0.41.0 (registry+https://github.com/rust-lang/crates.io-index)",
"cexpr 0.2.0 (registry+https://github.com/rust-lang/crates.io-index)",
diff --git a/Cargo.toml b/Cargo.toml
index 549de642..0f17dc8e 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -13,7 +13,7 @@ name = "bindgen"
readme = "README.md"
repository = "https://github.com/servo/rust-bindgen"
documentation = "https://docs.rs/bindgen"
-version = "0.25.3"
+version = "0.26.1"
build = "build.rs"
exclude = [
diff --git a/bindgen-integration/build.rs b/bindgen-integration/build.rs
index b715486c..7107d04b 100644
--- a/bindgen-integration/build.rs
+++ b/bindgen-integration/build.rs
@@ -28,7 +28,6 @@ fn main() {
let macros = Arc::new(RwLock::new(HashSet::new()));
let bindings = Builder::default()
- .no_unstable_rust()
.enable_cxx_namespaces()
.raw_line("pub use self::root::*;")
.header("cpp/Test.h")
diff --git a/bindgen-integration/cpp/Test.cc b/bindgen-integration/cpp/Test.cc
index 9d91250c..f125109a 100644
--- a/bindgen-integration/cpp/Test.cc
+++ b/bindgen-integration/cpp/Test.cc
@@ -76,4 +76,29 @@ Date2::assert(unsigned short nWeekDay,
this->byte == byte;
}
+bool
+Fifth::assert(unsigned short nWeekDay,
+ unsigned short nMonthDay,
+ unsigned short nMonth,
+ unsigned short nYear,
+ unsigned char byte)
+{
+ return this->nWeekDay == nWeekDay &&
+ this->nMonthDay == nMonthDay &&
+ this->nMonth == nMonth &&
+ this->nYear == nYear &&
+ this->byte == byte;
+}
+
+bool
+Sixth::assert(unsigned char byte,
+ unsigned char nWeekDay,
+ unsigned char nMonth,
+ unsigned char nMonthDay) {
+ return this->nWeekDay == nWeekDay &&
+ this->nMonthDay == nMonthDay &&
+ this->nMonth == nMonth &&
+ this->byte == byte;
+};
+
} // namespace bitfields
diff --git a/bindgen-integration/cpp/Test.h b/bindgen-integration/cpp/Test.h
index 4b8c1690..e23a32e6 100644
--- a/bindgen-integration/cpp/Test.h
+++ b/bindgen-integration/cpp/Test.h
@@ -92,6 +92,36 @@ struct Date2 {
unsigned short byte);
};
+
+struct Fifth {
+ 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;
+
+ /// Returns true if the bitfields match the arguments, false otherwise.
+ bool assert(unsigned short nWeekDay,
+ unsigned short nMonthDay,
+ unsigned short nMonth,
+ unsigned short nYear,
+ unsigned char byte);
+};
+
+struct Sixth {
+ unsigned char byte;
+ unsigned char nWeekDay : 3;
+ unsigned char nMonth : 5;
+ unsigned char nMonthDay : 6;
+
+ /// Returns true if the bitfields match the arguments, false otherwise.
+ bool assert(unsigned char byte,
+ unsigned char nWeekDay,
+ unsigned char nMonth,
+ unsigned char nMonthDay);
+};
+
+
} // namespace bitfields
struct AutoRestoreBool {
diff --git a/bindgen-integration/src/lib.rs b/bindgen-integration/src/lib.rs
index ea2b77b2..fdb02dbb 100755
--- a/bindgen-integration/src/lib.rs
+++ b/bindgen-integration/src/lib.rs
@@ -138,6 +138,48 @@ fn test_bitfields_date2() {
}
#[test]
+fn test_bitfields_fifth() {
+ let mut date: bindings::bitfields::Fifth = unsafe {
+ mem::zeroed()
+ };
+
+ assert!(unsafe {
+ date.assert(0, 0, 0, 0, 0)
+ });
+
+ date.byte = 255; // Set this first, to ensure we don't override it.
+
+ date.set_nWeekDay(6); // saturdays are the best
+ date.set_nMonthDay(20);
+ date.set_nMonth(11);
+ date.set_nYear(95);
+
+ assert!(unsafe {
+ date.assert(6, 20, 11, 95, 255)
+ });
+}
+
+#[test]
+fn test_bitfields_sixth() {
+ let mut date: bindings::bitfields::Sixth = unsafe {
+ mem::zeroed()
+ };
+
+ assert!(unsafe {
+ date.assert(0, 0, 0, 0)
+ });
+
+ date.byte = 255;
+ date.set_nWeekDay(6); // saturdays are the best
+ date.set_nMonthDay(20);
+ date.set_nMonth(11);
+
+ assert!(unsafe {
+ date.assert(255, 6, 11, 20)
+ });
+}
+
+#[test]
fn test_bitfield_constructors() {
use std::mem;
let mut first = bindings::bitfields::First {
diff --git a/book/src/tutorial-3.md b/book/src/tutorial-3.md
index a6a7135e..41197aa0 100644
--- a/book/src/tutorial-3.md
+++ b/book/src/tutorial-3.md
@@ -22,10 +22,6 @@ fn main() {
// to bindgen, and lets you build up options for
// the resulting bindings.
let bindings = bindgen::Builder::default()
- // Do not generate unstable Rust code that
- // requires a nightly rustc and enabling
- // unstable features.
- .no_unstable_rust()
// The input header we would like to generate
// bindings for.
.header("wrapper.h")
diff --git a/book/src/using-unions.md b/book/src/using-unions.md
index 66ba6d13..9ee10a92 100644
--- a/book/src/using-unions.md
+++ b/book/src/using-unions.md
@@ -1,6 +1,8 @@
# Using the Union Types Generated by Bindgen
-**NOTE:** As of Rust version 1.17, Rust does not have a stable `union` type. Issue [#32836](https://github.com/rust-lang/rust/issues/32836) tracks the stabilization of a `union` type in Rust. By default, bindgen will generate the preliminary unstable `union` type, unless the flag `--no-unstable-rust` flag is used.
+**NOTE:** As of Rust version 1.17, Rust does not have a stable `union` type. Issue [#32836](https://github.com/rust-lang/rust/issues/32836) tracks the stabilization of a `union` type in Rust.
+
+By using the flag `--unstable-rust`, bindgen will generate the preliminary unstable `union` type.
In general, most interactions with unions (either reading or writing) are unsafe.
@@ -29,12 +31,12 @@ typedef union {
### Library
-* [`bindgen::Builder::no_unstable_rust()`](https://docs.rs/bindgen/0.25.3/bindgen/struct.Builder.html#method.no_unstable_rust)
+* [`bindgen::Builder::unstable_rust()`](https://docs.rs/bindgen/0.25.3/bindgen/struct.Builder.html#method.unstable_rust)
* [`bindgen::Builder::derive_default()`](https://docs.rs/bindgen/0.25.3/bindgen/struct.Builder.html#method.derive_default)
### Command Line
-* `--no-unstable-rust`
+* `--unstable-rust`
* `--with-derive-default`
## Using the unstable `union` version
@@ -129,4 +131,4 @@ error[E0308]: mismatched types
|
= note: expected type `bindings::__BindgenUnionField<bindings::alpha_t>`
found type `bindings::alpha_t`
-``` \ No newline at end of file
+```
diff --git a/src/clang.rs b/src/clang.rs
index cdadce1c..6e1f426c 100644
--- a/src/clang.rs
+++ b/src/clang.rs
@@ -1361,55 +1361,31 @@ impl TranslationUnit {
-> Option<Vec<cexpr::token::Token>> {
use cexpr::token;
- let mut tokens = match self.tokens(cursor) {
- Some(tokens) => tokens,
- None => return None,
- };
-
- // FIXME(emilio): LLVM 3.9 at least always include an extra token for no
- // good reason (except if we're at EOF). So we do this kind of hack,
- // where we skip known-to-cause problems trailing punctuation and
- // trailing keywords.
- //
- // This is sort of unfortunate, though :(.
- //
- // I'll try to get it fixed in LLVM if I have the time to submit a
- // patch.
- let mut trim_last_token = false;
- if let Some(token) = tokens.last() {
- // The starting of the next macro.
- trim_last_token |= token.spelling == "#" &&
- token.kind == CXToken_Punctuation;
-
- // A following keyword of any kind, like a following declaration.
- trim_last_token |= token.kind == CXToken_Keyword;
- }
-
- if trim_last_token {
- tokens.pop().unwrap();
- }
-
- Some(tokens.into_iter()
- .filter_map(|token| {
- let kind = match token.kind {
- CXToken_Punctuation => token::Kind::Punctuation,
- CXToken_Literal => token::Kind::Literal,
- CXToken_Identifier => token::Kind::Identifier,
- CXToken_Keyword => token::Kind::Keyword,
- // NB: cexpr is not too happy about comments inside
- // expressions, so we strip them down here.
- CXToken_Comment => return None,
- _ => {
- panic!("Found unexpected token kind: {:?}", token.kind)
- }
- };
-
- Some(token::Token {
- kind: kind,
- raw: token.spelling.into_bytes().into_boxed_slice(),
+ self.tokens(cursor).map(|tokens| {
+ tokens
+ .into_iter()
+ .filter_map(|token| {
+ let kind = match token.kind {
+ CXToken_Punctuation => token::Kind::Punctuation,
+ CXToken_Literal => token::Kind::Literal,
+ CXToken_Identifier => token::Kind::Identifier,
+ CXToken_Keyword => token::Kind::Keyword,
+ // NB: cexpr is not too happy about comments inside
+ // expressions, so we strip them down here.
+ CXToken_Comment => return None,
+ _ => {
+ error!("Found unexpected token kind: {:?}", token);
+ return None
+ }
+ };
+
+ Some(token::Token {
+ kind: kind,
+ raw: token.spelling.into_bytes().into_boxed_slice(),
+ })
})
- })
- .collect::<Vec<_>>())
+ .collect::<Vec<_>>()
+ })
}
}
diff --git a/src/codegen/mod.rs b/src/codegen/mod.rs
index 8f9f0ee7..d926f02b 100644
--- a/src/codegen/mod.rs
+++ b/src/codegen/mod.rs
@@ -23,7 +23,7 @@ use ir::item_kind::ItemKind;
use ir::layout::Layout;
use ir::module::Module;
use ir::objc::{ObjCInterface, ObjCMethod};
-use ir::template::{AsNamed, TemplateInstantiation, TemplateParameters};
+use ir::template::{AsTemplateParam, TemplateInstantiation, TemplateParameters};
use ir::ty::{Type, TypeKind};
use ir::var::Var;
@@ -437,6 +437,16 @@ impl CodeGenerator for Var {
}
result.saw_var(&canonical_name);
+ // We can't generate bindings to static variables of templates. The
+ // number of actual variables for a single declaration are open ended
+ // and we don't know what instantiations do or don't exist.
+ let type_params = item.all_template_params(ctx);
+ if let Some(params) = type_params {
+ if !params.is_empty() {
+ return;
+ }
+ }
+
let ty = self.ty().to_rust_ty_or_opaque(ctx, &());
if let Some(val) = self.val() {
@@ -643,7 +653,7 @@ impl CodeGenerator for Type {
if let Some(ref params) = used_template_params {
for template_param in params {
if let Some(id) =
- template_param.as_named(ctx, &()) {
+ template_param.as_template_param(ctx, &()) {
let template_param = ctx.resolve_type(id);
if template_param.is_invalid_named_type() {
warn!("Item contained invalid template \
@@ -754,6 +764,13 @@ impl CodeGenerator for TemplateInstantiation {
return
}
+ // If there are any unbound type parameters, then we can't generate a
+ // layout test because we aren't dealing with a concrete type with a
+ // concrete size and alignment.
+ if ctx.uses_any_template_parameters(item.id()) {
+ return;
+ }
+
let layout = item.kind().expect_type().layout(ctx);
if let Some(layout) = layout {
@@ -761,8 +778,11 @@ impl CodeGenerator for TemplateInstantiation {
let align = layout.align;
let name = item.canonical_name(ctx);
- let fn_name = format!("__bindgen_test_layout_{}_instantiation_{}",
- name, item.exposed_id(ctx));
+ let mut fn_name = format!("__bindgen_test_layout_{}_instantiation", name);
+ let times_seen = result.overload_number(&fn_name);
+ if times_seen > 0 {
+ write!(&mut fn_name, "_{}", times_seen).unwrap();
+ }
let fn_name = ctx.rust_ident_raw(&fn_name);
@@ -1115,9 +1135,9 @@ impl Bitfield {
#[inline]
$fn_prefix $ctor_name($params $param_name : $bitfield_ty)
-> $unit_field_int_ty {
- ($body |
- (($param_name as $bitfield_int_ty as $unit_field_int_ty) << $offset) &
- ($mask as $unit_field_int_ty))
+ ($body |
+ (($param_name as $bitfield_int_ty as $unit_field_int_ty) << $offset) &
+ ($mask as $unit_field_int_ty))
}
}
).unwrap()
@@ -1149,12 +1169,18 @@ impl<'a> FieldCodegen<'a> for BitfieldUnit {
.build_ty(field_ty.clone());
fields.extend(Some(field));
- let unit_field_int_ty = match self.layout().size {
+ let mut field_int_size = self.layout().size;
+ if !field_int_size.is_power_of_two() {
+ field_int_size = field_int_size.next_power_of_two();
+ }
+
+ let unit_field_int_ty = match field_int_size {
8 => quote_ty!(ctx.ext_cx(), u64),
4 => quote_ty!(ctx.ext_cx(), u32),
2 => quote_ty!(ctx.ext_cx(), u16),
1 => quote_ty!(ctx.ext_cx(), u8),
- _ => {
+ size => {
+ debug_assert!(size > 8);
// Can't generate bitfield accessors for unit sizes larget than
// 64 bits at the moment.
struct_layout.saw_bitfield_unit(self.layout());
@@ -1275,17 +1301,26 @@ impl<'a> FieldCodegen<'a> for Bitfield {
let bitfield_ty = bitfield_ty.to_rust_ty_or_opaque(ctx, bitfield_ty_item);
let offset = self.offset_into_unit();
- let mask: usize = self.mask();
+ let mask = self.mask();
let impl_item = quote_item!(
ctx.ext_cx(),
impl XxxIgnored {
#[inline]
pub fn $getter_name(&self) -> $bitfield_ty {
- let mask = $mask as $unit_field_int_ty;
- let unit_field_val: $unit_field_int_ty = unsafe {
- ::$prefix::mem::transmute(self.$unit_field_ident)
+ let mut unit_field_val: $unit_field_int_ty = unsafe {
+ ::$prefix::mem::uninitialized()
+ };
+
+ unsafe {
+ ::$prefix::ptr::copy_nonoverlapping(
+ &self.$unit_field_ident as *const _ as *const u8,
+ &mut unit_field_val as *mut $unit_field_int_ty as *mut u8,
+ ::$prefix::mem::size_of::<$unit_field_int_ty>(),
+ )
};
+
+ let mask = $mask as $unit_field_int_ty;
let val = (unit_field_val & mask) >> $offset;
unsafe {
::$prefix::mem::transmute(val as $bitfield_int_ty)
@@ -1298,14 +1333,27 @@ impl<'a> FieldCodegen<'a> for Bitfield {
let val = val as $bitfield_int_ty as $unit_field_int_ty;
let mut unit_field_val: $unit_field_int_ty = unsafe {
- ::$prefix::mem::transmute(self.$unit_field_ident)
+ ::$prefix::mem::uninitialized()
};
+
+ unsafe {
+ ::$prefix::ptr::copy_nonoverlapping(
+ &self.$unit_field_ident as *const _ as *const u8,
+ &mut unit_field_val as *mut $unit_field_int_ty as *mut u8,
+ ::$prefix::mem::size_of::<$unit_field_int_ty>(),
+ )
+ };
+
unit_field_val &= !mask;
unit_field_val |= (val << $offset) & mask;
- self.$unit_field_ident = unsafe {
- ::$prefix::mem::transmute(unit_field_val)
- };
+ unsafe {
+ ::$prefix::ptr::copy_nonoverlapping(
+ &unit_field_val as *const _ as *const u8,
+ &mut self.$unit_field_ident as *mut _ as *mut u8,
+ ::$prefix::mem::size_of::<$unit_field_int_ty>(),
+ );
+ }
}
}
).unwrap();
@@ -2323,7 +2371,8 @@ impl CodeGenerator for Enum {
builder = builder.with_attr(derives);
}
- fn add_constant<'a>(enum_: &Type,
+ fn add_constant<'a>(ctx: &BindgenContext,
+ enum_: &Type,
// Only to avoid recomputing every time.
enum_canonical_name: &str,
// May be the same as "variant" if it's because the
@@ -2334,7 +2383,11 @@ impl CodeGenerator for Enum {
enum_rust_ty: P<ast::Ty>,
result: &mut CodegenResult<'a>) {
let constant_name = if enum_.name().is_some() {
- format!("{}_{}", enum_canonical_name, variant_name)
+ if ctx.options().prepend_enum_name {
+ format!("{}_{}", enum_canonical_name, variant_name)
+ } else {
+ variant_name.into()
+ }
} else {
variant_name.into()
};
@@ -2418,7 +2471,8 @@ impl CodeGenerator for Enum {
};
let existing_variant_name = entry.get();
- add_constant(enum_ty,
+ add_constant(ctx,
+ enum_ty,
&name,
&*mangled_name,
existing_variant_name,
@@ -2457,7 +2511,8 @@ impl CodeGenerator for Enum {
variant_name))
};
- add_constant(enum_ty,
+ add_constant(ctx,
+ enum_ty,
&name,
&mangled_name,
&variant_name,
@@ -2769,7 +2824,7 @@ impl TryToRustTy for Type {
let template_params = item.used_template_params(ctx)
.unwrap_or(vec![])
.into_iter()
- .filter(|param| param.is_named(ctx, &()))
+ .filter(|param| param.is_template_param(ctx, &()))
.collect::<Vec<_>>();
let spelling = self.name().expect("Unnamed alias?");
@@ -2960,6 +3015,17 @@ impl CodeGenerator for Function {
item: &Item) {
debug!("<Function as CodeGenerator>::codegen: item = {:?}", item);
+ // Similar to static member variables in a class template, we can't
+ // generate bindings to template functions, because the set of
+ // instantiations is open ended and we have no way of knowing which
+ // monomorphizations actually exist.
+ let type_params = item.all_template_params(ctx);
+ if let Some(params) = type_params {
+ if !params.is_empty() {
+ return;
+ }
+ }
+
let name = self.name();
let mut canonical_name = item.canonical_name(ctx);
let mangled_name = self.mangled_name();
diff --git a/src/ir/comp.rs b/src/ir/comp.rs
index 5be20416..315d342a 100644
--- a/src/ir/comp.rs
+++ b/src/ir/comp.rs
@@ -293,8 +293,18 @@ impl Bitfield {
/// Get the mask value that when &'ed with this bitfield's allocation unit
/// produces this bitfield's value.
- pub fn mask(&self) -> usize {
- ((1usize << self.width()) - 1usize) << self.offset_into_unit()
+ pub fn mask(&self) -> u64 {
+ use std::mem;
+ use std::u64;
+
+ let unoffseted_mask =
+ if self.width() as u64 == mem::size_of::<u64>() as u64 * 8 {
+ u64::MAX
+ } else {
+ ((1u64 << self.width()) - 1u64)
+ };
+
+ unoffseted_mask << self.offset_into_unit()
}
/// Get the bit width of this bitfield.
@@ -475,8 +485,9 @@ fn bitfields_to_allocation_units<E, I>(ctx: &BindgenContext,
where E: Extend<Field>
{
*bitfield_unit_count += 1;
- let layout = Layout::new(bytes_from_bits_pow2(unit_size_in_bits),
- bytes_from_bits_pow2(unit_align_in_bits));
+ let align = bytes_from_bits_pow2(unit_align_in_bits);
+ let size = align_to(unit_size_in_bits, align * 8) / 8;
+ let layout = Layout::new(size, align);
fields.extend(Some(Field::Bitfields(BitfieldUnit {
nth: *bitfield_unit_count,
layout: layout,
diff --git a/src/ir/context.rs b/src/ir/context.rs
index a70425c7..eb0fd98a 100644
--- a/src/ir/context.rs
+++ b/src/ir/context.rs
@@ -2,7 +2,7 @@
use super::derive::{CanDeriveCopy, CanDeriveDebug, CanDeriveDefault};
use super::int::IntKind;
-use super::item::{Item, ItemCanonicalPath, ItemSet};
+use super::item::{Item, ItemAncestors, ItemCanonicalPath, ItemSet};
use super::item_kind::ItemKind;
use super::module::{Module, ModuleKind};
use super::named::{UsedTemplateParameters, analyze};
@@ -139,9 +139,6 @@ pub struct BindgenContext<'ctx> {
/// The active replacements collected from replaces="xxx" annotations.
replacements: HashMap<Vec<String>, ItemId>,
- /// The target string bindgen was able to deduce from the input.
- effective_target: String,
-
collected_typerefs: bool,
/// Dummy structures for code generation.
@@ -168,6 +165,9 @@ pub struct BindgenContext<'ctx> {
/// The set of `TypeKind::Comp` items found during parsing that need their
/// bitfield allocation units computed. Drained in `compute_bitfield_units`.
need_bitfield_allocation: Vec<ItemId>,
+
+ /// Whether we need the mangling hack which removes the prefixing underscore.
+ needs_mangling_hack: bool,
}
/// A traversal of whitelisted items.
@@ -261,6 +261,16 @@ impl<'ctx> BindgenContext<'ctx> {
effective_target = Some(HOST_TARGET.to_owned());
}
+ // Mac os and Win32 need __ for mangled symbols but rust will automatically
+ // prepend the extra _.
+ //
+ // We need to make sure that we don't include __ because rust will turn into
+ // ___.
+ let effective_target = effective_target.unwrap();
+ let needs_mangling_hack =
+ effective_target.contains("darwin") ||
+ effective_target == "i686-pc-win32";
+
let root_module = Self::build_root_module(ItemId(0));
let mut me = BindgenContext {
items: Default::default(),
@@ -273,7 +283,6 @@ impl<'ctx> BindgenContext<'ctx> {
currently_parsed_types: vec![],
parsed_macros: Default::default(),
replacements: Default::default(),
- effective_target: effective_target.unwrap(),
collected_typerefs: false,
gen_ctx: None,
span: DUMMY_SP,
@@ -283,6 +292,7 @@ impl<'ctx> BindgenContext<'ctx> {
generated_bindegen_complex: Cell::new(false),
used_template_parameters: None,
need_bitfield_allocation: Default::default(),
+ needs_mangling_hack: needs_mangling_hack,
};
me.add_item(root_module, None, None);
@@ -338,14 +348,8 @@ impl<'ctx> BindgenContext<'ctx> {
let is_template_instantiation =
is_type && item.expect_type().is_template_instantiation();
- // Be sure to track all the generated children under namespace, even
- // those generated after resolving typerefs, etc.
- if item.id() != item.parent_id() {
- if let Some(mut parent) = self.items.get_mut(&item.parent_id()) {
- if let Some(mut module) = parent.as_module_mut() {
- module.children_mut().push(item.id());
- }
- }
+ if item.id() != self.root_module {
+ self.add_item_to_module(&item);
}
if is_type && item.expect_type().is_comp() {
@@ -397,6 +401,38 @@ impl<'ctx> BindgenContext<'ctx> {
}
}
+ /// Ensure that every item (other than the root module) is in a module's
+ /// children list. This is to make sure that every whitelisted item get's
+ /// codegen'd, even if its parent is not whitelisted. See issue #769 for
+ /// details.
+ fn add_item_to_module(&mut self, item: &Item) {
+ assert!(item.id() != self.root_module);
+ assert!(!self.items.contains_key(&item.id()));
+
+ if let Some(mut parent) = self.items.get_mut(&item.parent_id()) {
+ if let Some(mut module) = parent.as_module_mut() {
+ debug!("add_item_to_module: adding {:?} as child of parent module {:?}",
+ item.id(),
+ item.parent_id());
+
+ module.children_mut().insert(item.id());
+ return;
+ }
+ }
+
+ debug!("add_item_to_module: adding {:?} as child of current module {:?}",
+ item.id(),
+ self.current_module);
+
+ self.items
+ .get_mut(&self.current_module)
+ .expect("Should always have an item for self.current_module")
+ .as_module_mut()
+ .expect("self.current_module should always be a module")
+ .children_mut()
+ .insert(item.id());
+ }
+
/// Add a new named template type parameter to this context's item set.
pub fn add_named_type(&mut self, item: Item, definition: clang::Cursor) {
debug!("BindgenContext::add_named_type: item = {:?}; definition = {:?}",
@@ -408,6 +444,8 @@ impl<'ctx> BindgenContext<'ctx> {
assert_eq!(definition.kind(),
clang_sys::CXCursor_TemplateTypeParameter);
+ self.add_item_to_module(&item);
+
let id = item.id();
let old_item = self.items.insert(id, item);
assert!(old_item.is_none(),
@@ -610,41 +648,65 @@ impl<'ctx> BindgenContext<'ctx> {
item.parent_id()
};
+ // Relocate the replacement item from where it was declared, to
+ // where the thing it is replacing was declared.
+ //
+ // First, we'll make sure that its parent id is correct.
- // Reparent the item.
let old_parent = self.resolve_item(replacement).parent_id();
-
if new_parent == old_parent {
+ // Same parent and therefore also same containing
+ // module. Nothing to do here.
continue;
}
- if let Some(mut module) = self.items
- .get_mut(&old_parent)
+ self.items
+ .get_mut(&replacement)
.unwrap()
- .as_module_mut() {
- // Deparent the replacement.
- let position = module.children()
- .iter()
- .position(|id| *id == replacement)
- .unwrap();
- module.children_mut().remove(position);
- }
+ .set_parent_for_replacement(new_parent);
- if let Some(mut module) = self.items
- .get_mut(&new_parent)
- .unwrap()
- .as_module_mut() {
- module.children_mut().push(replacement);
+ // Second, make sure that it is in the correct module's children
+ // set.
+
+ let old_module = {
+ let immut_self = &*self;
+ old_parent.ancestors(immut_self)
+ .chain(Some(immut_self.root_module))
+ .find(|id| {
+ let item = immut_self.resolve_item(*id);
+ item.as_module().map_or(false, |m| m.children().contains(&replacement))
+ })
+ };
+ let old_module = old_module.expect("Every replacement item should be in a module");
+
+ let new_module = {
+ let immut_self = &*self;
+ new_parent.ancestors(immut_self).find(|id| {
+ immut_self.resolve_item(*id).is_module()
+ })
+ };
+ let new_module = new_module.unwrap_or(self.root_module);
+
+ if new_module == old_module {
+ // Already in the correct module.
+ continue;
}
self.items
- .get_mut(&replacement)
+ .get_mut(&old_module)
.unwrap()
- .set_parent_for_replacement(new_parent);
+ .as_module_mut()
+ .unwrap()
+ .children_mut()
+ .remove(&replacement);
+
self.items
- .get_mut(&id)
+ .get_mut(&new_module)
+ .unwrap()
+ .as_module_mut()
.unwrap()
- .set_parent_for_replacement(old_parent);
+ .children_mut()
+ .insert(replacement);
}
}
@@ -687,6 +749,11 @@ impl<'ctx> BindgenContext<'ctx> {
self.process_replacements();
}
+ // Make sure to do this after processing replacements, since that messes
+ // with the parentage and module children, and we want to assert that it
+ // messes with them correctly.
+ self.assert_every_item_in_a_module();
+
self.find_used_template_parameters();
let ret = cb(self);
@@ -717,6 +784,42 @@ impl<'ctx> BindgenContext<'ctx> {
traversal::all_edges)
}
+ /// When the `testing_only_extra_assertions` feature is enabled, walk over
+ /// every item and ensure that it is in the children set of one of its
+ /// module ancestors.
+ fn assert_every_item_in_a_module(&self) {
+ if cfg!(feature = "testing_only_extra_assertions") {
+ assert!(self.in_codegen_phase());
+ assert!(self.current_module == self.root_module);
+
+ for (&id, _item) in self.items() {
+ if id == self.root_module {
+ continue;
+ }
+
+ assert!(
+ {
+ let id = id.into_resolver()
+ .through_type_refs()
+ .through_type_aliases()
+ .resolve(self)
+ .id();
+ id.ancestors(self)
+ .chain(Some(self.root_module))
+ .any(|ancestor| {
+ debug!("Checking if {:?} is a child of {:?}", id, ancestor);
+ self.resolve_item(ancestor)
+ .as_module()
+ .map_or(false, |m| m.children().contains(&id))
+ })
+ },
+ "{:?} should be in some ancestor module's children set",
+ id
+ );
+ }
+ }
+ }
+
fn find_used_template_parameters(&mut self) {
if self.options.whitelist_recursively {
let used_params = analyze::<UsedTemplateParameters>(self);
@@ -773,6 +876,21 @@ impl<'ctx> BindgenContext<'ctx> {
.map_or(false, |items_used_params| items_used_params.contains(&template_param))
}
+ /// Return `true` if `item` uses any unbound, generic template parameters,
+ /// `false` otherwise.
+ ///
+ /// Has the same restrictions that `uses_template_parameter` has.
+ pub fn uses_any_template_parameters(&self, item: ItemId) -> bool {
+ assert!(self.in_codegen_phase(),
+ "We only compute template parameter usage as we enter codegen");
+
+ self.used_template_parameters
+ .as_ref()
+ .expect("should have template parameter usage info in codegen phase")
+ .get(&item)
+ .map_or(false, |used| !used.is_empty())
+ }
+
// This deserves a comment. Builtin types don't get a valid declaration, so
// we can't add it to the cursor->type map.
//
@@ -784,6 +902,7 @@ impl<'ctx> BindgenContext<'ctx> {
fn add_builtin_item(&mut self, item: Item) {
debug!("add_builtin_item: item = {:?}", item);
debug_assert!(item.kind().is_type());
+ self.add_item_to_module(&item);
let id = item.id();
let old_item = self.items.insert(id, item);
assert!(old_item.is_none(), "Inserted type twice?");
@@ -795,8 +914,8 @@ impl<'ctx> BindgenContext<'ctx> {
}
/// Returns the target triple bindgen is running over.
- pub fn target(&self) -> &str {
- &self.effective_target
+ pub fn needs_mangling_hack(&self) -> bool {
+ self.needs_mangling_hack
}
/// Get the root module.
@@ -919,10 +1038,14 @@ impl<'ctx> BindgenContext<'ctx> {
/// Incomplete<U> bar;
/// };
/// ```
+ ///
+ /// Finally, template instantiations are always children of the current
+ /// module. They use their template's definition for their name, so the
+ /// parent is only useful for ensuring that their layout tests get
+ /// codegen'd.
fn instantiate_template(&mut self,
with_id: ItemId,
template: ItemId,
- parent_id: ItemId,
ty: &clang::Type,
location: clang::Cursor)
-> Option<ItemId> {
@@ -1028,13 +1151,14 @@ impl<'ctx> BindgenContext<'ctx> {
let sub_item = Item::new(sub_id,
None,
None,
- template_decl_id,
+ self.current_module,
ItemKind::Type(sub_ty));
// Bypass all the validations in add_item explicitly.
debug!("instantiate_template: inserting nested \
instantiation item: {:?}",
sub_item);
+ self.add_item_to_module(&sub_item);
debug_assert!(sub_id == sub_item.id());
self.items.insert(sub_id, sub_item);
args.push(sub_id);
@@ -1076,10 +1200,11 @@ impl<'ctx> BindgenContext<'ctx> {
type_kind,
ty.is_const());
let item =
- Item::new(with_id, None, None, parent_id, ItemKind::Type(ty));
+ Item::new(with_id, None, None, self.current_module, ItemKind::Type(ty));
// Bypass all the validations in add_item explicitly.
debug!("instantiate_template: inserting item: {:?}", item);
+ self.add_item_to_module(&item);
debug_assert!(with_id == item.id());
self.items.insert(with_id, item);
Some(with_id)
@@ -1133,11 +1258,6 @@ impl<'ctx> BindgenContext<'ctx> {
location.is_some() {
let location = location.unwrap();
- // It is always safe to hang instantiations off of the root
- // module. They use their template definition for naming,
- // and don't need the parent for anything else.
- let parent_id = self.root_module();
-
// For specialized type aliases, there's no way to get the
// template parameters as of this writing (for a struct
// specialization we wouldn't be in this branch anyway).
@@ -1156,7 +1276,6 @@ impl<'ctx> BindgenContext<'ctx> {
return self.instantiate_template(with_id,
id,
- parent_id,
ty,
location)
.or_else(|| Some(id));
diff --git a/src/ir/dot.rs b/src/ir/dot.rs
index 40202b2c..61954c44 100644
--- a/src/ir/dot.rs
+++ b/src/ir/dot.rs
@@ -55,6 +55,15 @@ pub fn write_dot_file<P>(ctx: &BindgenContext, path: P) -> io::Result<()>
if let Some(err) = err {
return err;
}
+
+ if let Some(module) = item.as_module() {
+ for child in module.children() {
+ try!(writeln!(&mut dot_file,
+ "{} -> {} [style=dotted]",
+ item.id().as_usize(),
+ child.as_usize()));
+ }
+ }
}
try!(writeln!(&mut dot_file, "}}"));
diff --git a/src/ir/function.rs b/src/ir/function.rs
index 6281306b..9865997d 100644
--- a/src/ir/function.rs
+++ b/src/ir/function.rs
@@ -128,16 +128,8 @@ fn get_abi(cc: CXCallingConv) -> Abi {
})
}
-// Mac os and Win32 need __ for mangled symbols but rust will automatically
-// prepend the extra _.
-//
-// We need to make sure that we don't include __ because rust will turn into
-// ___.
fn mangling_hack_if_needed(ctx: &BindgenContext, symbol: &mut String) {
- // NB: win64 also contains the substring "win32" in the target triple, so
- // we need to actually check for i686...
- if ctx.target().contains("macos") ||
- (ctx.target().contains("i686") && ctx.target().contains("windows")) {
+ if ctx.needs_mangling_hack() {
symbol.remove(0);
}
}
diff --git a/src/ir/item.rs b/src/ir/item.rs
index de629e03..b80ddbd9 100644
--- a/src/ir/item.rs
+++ b/src/ir/item.rs
@@ -9,7 +9,7 @@ use super::function::Function;
use super::item_kind::ItemKind;
use super::layout::Opaque;
use super::module::Module;
-use super::template::{AsNamed, TemplateParameters};
+use super::template::{AsTemplateParam, TemplateParameters};
use super::traversal::{EdgeKind, Trace, Tracer};
use super::ty::{Type, TypeKind};
use clang;
@@ -132,28 +132,28 @@ impl<'a, 'b> Iterator for ItemAncestorsIter<'a, 'b>
}
}
-impl AsNamed for ItemId {
+impl AsTemplateParam for ItemId {
type Extra = ();
- fn as_named(&self, ctx: &BindgenContext, _: &()) -> Option<ItemId> {
- ctx.resolve_item(*self).as_named(ctx, &())
+ fn as_template_param(&self, ctx: &BindgenContext, _: &()) -> Option<ItemId> {
+ ctx.resolve_item(*self).as_template_param(ctx, &())
}
}
-impl AsNamed for Item {
+impl AsTemplateParam for Item {
type Extra = ();
- fn as_named(&self, ctx: &BindgenContext, _: &()) -> Option<ItemId> {
- self.kind.as_named(ctx, self)
+ fn as_template_param(&self, ctx: &BindgenContext, _: &()) -> Option<ItemId> {
+ self.kind.as_template_param(ctx, self)
}
}
-impl AsNamed for ItemKind {
+impl AsTemplateParam for ItemKind {
type Extra = Item;
- fn as_named(&self, ctx: &BindgenContext, item: &Item) -> Option<ItemId> {
+ fn as_template_param(&self, ctx: &BindgenContext, item: &Item) -> Option<ItemId> {
match *self {
- ItemKind::Type(ref ty) => ty.as_named(ctx, item),
+ ItemKind::Type(ref ty) => ty.as_template_param(ctx, item),
ItemKind::Module(..) |
ItemKind::Function(..) |
ItemKind::Var(..) => None,
@@ -757,7 +757,7 @@ impl Item {
// Named template type arguments are never namespaced, and never
// mangled.
- if target.is_named(ctx, &()) {
+ if target.is_template_param(ctx, &()) {
return base_name;
}
diff --git a/src/ir/module.rs b/src/ir/module.rs
index ee3912c5..09070247 100644
--- a/src/ir/module.rs
+++ b/src/ir/module.rs
@@ -1,7 +1,8 @@
//! Intermediate representation for modules (AKA C++ namespaces).
-use super::context::{BindgenContext, ItemId};
+use super::context::BindgenContext;
use super::dot::DotAttributes;
+use super::item::ItemSet;
use clang;
use parse::{ClangSubItemParser, ParseError, ParseResult};
use parse_one;
@@ -24,7 +25,7 @@ pub struct Module {
/// The kind of module this is.
kind: ModuleKind,
/// The children of this module, just here for convenience.
- children_ids: Vec<ItemId>,
+ children: ItemSet,
}
impl Module {
@@ -33,7 +34,7 @@ impl Module {
Module {
name: name,
kind: kind,
- children_ids: vec![],
+ children: ItemSet::new(),
}
}
@@ -43,13 +44,13 @@ impl Module {
}
/// Get a mutable reference to this module's children.
- pub fn children_mut(&mut self) -> &mut Vec<ItemId> {
- &mut self.children_ids
+ pub fn children_mut(&mut self) -> &mut ItemSet {
+ &mut self.children
}
/// Get this module's children.
- pub fn children(&self) -> &[ItemId] {
- &self.children_ids
+ pub fn children(&self) -> &ItemSet {
+ &self.children
}
/// Whether this namespace is inline.
diff --git a/src/ir/template.rs b/src/ir/template.rs
index 4ae0da04..722c1b81 100644
--- a/src/ir/template.rs
+++ b/src/ir/template.rs
@@ -176,19 +176,19 @@ pub trait TemplateParameters {
}
/// A trait for things which may or may not be a named template type parameter.
-pub trait AsNamed {
+pub trait AsTemplateParam {
/// Any extra information the implementor might need to make this decision.
type Extra;
/// Convert this thing to the item id of a named template type parameter.
- fn as_named(&self,
- ctx: &BindgenContext,
- extra: &Self::Extra)
- -> Option<ItemId>;
+ fn as_template_param(&self,
+ ctx: &BindgenContext,
+ extra: &Self::Extra)
+ -> Option<ItemId>;
/// Is this a named template type parameter?
- fn is_named(&self, ctx: &BindgenContext, extra: &Self::Extra) -> bool {
- self.as_named(ctx, extra).is_some()
+ fn is_template_param(&self, ctx: &BindgenContext, extra: &Self::Extra) -> bool {
+ self.as_template_param(ctx, extra).is_some()
}
}
diff --git a/src/ir/ty.rs b/src/ir/ty.rs
index fd8e45c1..3e5f53b0 100644
--- a/src/ir/ty.rs
+++ b/src/ir/ty.rs
@@ -10,7 +10,7 @@ use super::int::IntKind;
use super::item::Item;
use super::layout::{Layout, Opaque};
use super::objc::ObjCInterface;
-use super::template::{AsNamed, TemplateInstantiation, TemplateParameters};
+use super::template::{AsTemplateParam, TemplateInstantiation, TemplateParameters};
use super::traversal::{EdgeKind, Trace, Tracer};
use clang::{self, Cursor};
use parse::{ClangItemParser, ParseError, ParseResult};
@@ -374,21 +374,21 @@ impl Type {
}
}
-impl AsNamed for Type {
+impl AsTemplateParam for Type {
type Extra = Item;
- fn as_named(&self, ctx: &BindgenContext, item: &Item) -> Option<ItemId> {
- self.kind.as_named(ctx, item)
+ fn as_template_param(&self, ctx: &BindgenContext, item: &Item) -> Option<ItemId> {
+ self.kind.as_template_param(ctx, item)
}
}
-impl AsNamed for TypeKind {
+impl AsTemplateParam for TypeKind {
type Extra = Item;
- fn as_named(&self, ctx: &BindgenContext, item: &Item) -> Option<ItemId> {
+ fn as_template_param(&self, ctx: &BindgenContext, item: &Item) -> Option<ItemId> {
match *self {
TypeKind::Named => Some(item.id()),
- TypeKind::ResolvedTypeRef(id) => id.as_named(ctx, &()),
+ TypeKind::ResolvedTypeRef(id) => id.as_template_param(ctx, &()),
_ => None,
}
}
diff --git a/src/ir/var.rs b/src/ir/var.rs
index 656a1a6d..b1efc57a 100644
--- a/src/ir/var.rs
+++ b/src/ir/var.rs
@@ -284,17 +284,35 @@ fn parse_macro(ctx: &BindgenContext,
-> Option<(Vec<u8>, cexpr::expr::EvalResult)> {
use cexpr::{expr, nom};
- let cexpr_tokens = match unit.cexpr_tokens(cursor) {
+ let mut cexpr_tokens = match unit.cexpr_tokens(cursor) {
None => return None,
Some(tokens) => tokens,
};
let parser = expr::IdentifierParser::new(ctx.parsed_macros());
- let result = parser.macro_definition(&cexpr_tokens);
- match result {
- nom::IResult::Done(_, (id, val)) => Some((id.into(), val)),
- _ => None,
+ match parser.macro_definition(&cexpr_tokens) {
+ nom::IResult::Done(_, (id, val)) => {
+ return Some((id.into(), val));
+ }
+ _ => {}
+ }
+
+ // Try without the last token, to workaround a libclang bug in versions
+ // previous to 4.0.
+ //
+ // See:
+ // https://bugs.llvm.org//show_bug.cgi?id=9069
+ // https://reviews.llvm.org/D26446
+ if cexpr_tokens.pop().is_none() {
+ return None;
+ }
+
+ match parser.macro_definition(&cexpr_tokens) {
+ nom::IResult::Done(_, (id, val)) => {
+ Some((id.into(), val))
+ }
+ _ => None
}
}
diff --git a/src/lib.rs b/src/lib.rs
index 2bcc21c0..bfa71d38 100644
--- a/src/lib.rs
+++ b/src/lib.rs
@@ -343,7 +343,7 @@ impl Builder {
}
if !self.options.unstable_rust {
- output_vector.push("--no-unstable-rust".into());
+ output_vector.push("--unstable-rust".into());
}
self.options
@@ -756,8 +756,8 @@ impl Builder {
}
/// Avoid generating any unstable Rust, such as Rust unions, in the generated bindings.
- pub fn no_unstable_rust(mut self) -> Builder {
- self.options.unstable_rust = false;
+ pub fn unstable_rust(mut self, doit: bool) -> Self {
+ self.options.unstable_rust = doit;
self
}
@@ -984,7 +984,7 @@ impl Default for BindgenOptions {
derive_default: false,
enable_cxx_namespaces: false,
disable_name_namespacing: false,
- unstable_rust: true,
+ unstable_rust: false,
use_core: false,
ctypes_prefix: None,
namespaced_constants: true,
diff --git a/src/options.rs b/src/options.rs
index 96f49849..6a6fde81 100644
--- a/src/options.rs
+++ b/src/options.rs
@@ -144,9 +144,9 @@ pub fn builder_from_flags<I>
Arg::with_name("no-prepend-enum-name")
.long("no-prepend-enum-name")
.help("Do not prepend the enum name to bitfield or constant variants."),
- Arg::with_name("no-unstable-rust")
- .long("no-unstable-rust")
- .help("Do not generate unstable Rust code.")
+ Arg::with_name("unstable-rust")
+ .long("unstable-rust")
+ .help("Generate unstable Rust code.")
.multiple(true), // FIXME: Pass legacy test suite
Arg::with_name("opaque-type")
.long("opaque-type")
@@ -339,8 +339,8 @@ pub fn builder_from_flags<I>
builder = builder.ignore_methods();
}
- if matches.is_present("no-unstable-rust") {
- builder = builder.no_unstable_rust();
+ if matches.is_present("unstable-rust") {
+ builder = builder.unstable_rust(true);
}
if matches.is_present("no-convert-floats") {
diff --git a/tests/expectations/tests/anon_union.rs b/tests/expectations/tests/anon_union.rs
index 5a12dccc..8b102c79 100644
--- a/tests/expectations/tests/anon_union.rs
+++ b/tests/expectations/tests/anon_union.rs
@@ -80,7 +80,7 @@ impl Default for ErrorResult {
fn default() -> Self { unsafe { ::std::mem::zeroed() } }
}
#[test]
-fn __bindgen_test_layout_TErrorResult_instantiation_1() {
+fn __bindgen_test_layout_TErrorResult_instantiation() {
assert_eq!(::std::mem::size_of::<TErrorResult>() , 24usize , concat ! (
"Size of template specialization: " , stringify ! (
TErrorResult ) ));
diff --git a/tests/expectations/tests/bitfield-32bit-overflow.rs b/tests/expectations/tests/bitfield-32bit-overflow.rs
new file mode 100644
index 00000000..d179ddf9
--- /dev/null
+++ b/tests/expectations/tests/bitfield-32bit-overflow.rs
@@ -0,0 +1,1600 @@
+/* automatically generated by rust-bindgen */
+
+
+#![allow(dead_code, non_snake_case, non_camel_case_types, non_upper_case_globals)]
+
+
+#[repr(C)]
+#[derive(Debug, Default, Copy)]
+pub struct MuchBitfield {
+ pub _bitfield_1: [u8; 5usize],
+ pub __bindgen_align: [u8; 0usize],
+}
+#[test]
+fn bindgen_test_layout_MuchBitfield() {
+ assert_eq!(::std::mem::size_of::<MuchBitfield>() , 5usize , concat ! (
+ "Size of: " , stringify ! ( MuchBitfield ) ));
+ assert_eq! (::std::mem::align_of::<MuchBitfield>() , 1usize , concat ! (
+ "Alignment of " , stringify ! ( MuchBitfield ) ));
+}
+impl Clone for MuchBitfield {
+ fn clone(&self) -> Self { *self }
+}
+impl MuchBitfield {
+ #[inline]
+ pub fn m0(&self) -> ::std::os::raw::c_char {
+ let mut unit_field_val: u64 = unsafe { ::std::mem::uninitialized() };
+ unsafe {
+ ::std::ptr::copy_nonoverlapping(&self._bitfield_1 as *const _ as
+ *const u8,
+ &mut unit_field_val as *mut u64 as
+ *mut u8,
+ ::std::mem::size_of::<u64>())
+ };
+ let mask = 1u64 as u64;
+ let val = (unit_field_val & mask) >> 0usize;
+ unsafe { ::std::mem::transmute(val as u8) }
+ }
+ #[inline]
+ pub fn set_m0(&mut self, val: ::std::os::raw::c_char) {
+ let mask = 1u64 as u64;
+ let val = val as u8 as u64;
+ let mut unit_field_val: u64 = unsafe { ::std::mem::uninitialized() };
+ unsafe {
+ ::std::ptr::copy_nonoverlapping(&self._bitfield_1 as *const _ as
+ *const u8,
+ &mut unit_field_val as *mut u64 as
+ *mut u8,
+ ::std::mem::size_of::<u64>())
+ };
+ unit_field_val &= !mask;
+ unit_field_val |= (val << 0usize) & mask;
+ unsafe {
+ ::std::ptr::copy_nonoverlapping(&unit_field_val as *const _ as
+ *const u8,
+ &mut self._bitfield_1 as *mut _ as
+ *mut u8,
+ ::std::mem::size_of::<u64>());
+ }
+ }
+ #[inline]
+ pub fn m1(&self) -> ::std::os::raw::c_char {
+ let mut unit_field_val: u64 = unsafe { ::std::mem::uninitialized() };
+ unsafe {
+ ::std::ptr::copy_nonoverlapping(&self._bitfield_1 as *const _ as
+ *const u8,
+ &mut unit_field_val as *mut u64 as
+ *mut u8,
+ ::std::mem::size_of::<u64>())
+ };
+ let mask = 2u64 as u64;
+ let val = (unit_field_val & mask) >> 1usize;
+ unsafe { ::std::mem::transmute(val as u8) }
+ }
+ #[inline]
+ pub fn set_m1(&mut self, val: ::std::os::raw::c_char) {
+ let mask = 2u64 as u64;
+ let val = val as u8 as u64;
+ let mut unit_field_val: u64 = unsafe { ::std::mem::uninitialized() };
+ unsafe {
+ ::std::ptr::copy_nonoverlapping(&self._bitfield_1 as *const _ as
+ *const u8,
+ &mut unit_field_val as *mut u64 as
+ *mut u8,
+ ::std::mem::size_of::<u64>())
+ };
+ unit_field_val &= !mask;
+ unit_field_val |= (val << 1usize) & mask;
+ unsafe {
+ ::std::ptr::copy_nonoverlapping(&unit_field_val as *const _ as
+ *const u8,
+ &mut self._bitfield_1 as *mut _ as
+ *mut u8,
+ ::std::mem::size_of::<u64>());
+ }
+ }
+ #[inline]
+ pub fn m2(&self) -> ::std::os::raw::c_char {
+ let mut unit_field_val: u64 = unsafe { ::std::mem::uninitialized() };
+ unsafe {
+ ::std::ptr::copy_nonoverlapping(&self._bitfield_1 as *const _ as
+ *const u8,
+ &mut unit_field_val as *mut u64 as
+ *mut u8,
+ ::std::mem::size_of::<u64>())
+ };
+ let mask = 4u64 as u64;
+ let val = (unit_field_val & mask) >> 2usize;
+ unsafe { ::std::mem::transmute(val as u8) }
+ }
+ #[inline]
+ pub fn set_m2(&mut self, val: ::std::os::raw::c_char) {
+ let mask = 4u64 as u64;
+ let val = val as u8 as u64;
+ let mut unit_field_val: u64 = unsafe { ::std::mem::uninitialized() };
+ unsafe {
+ ::std::ptr::copy_nonoverlapping(&self._bitfield_1 as *const _ as
+ *const u8,
+ &mut unit_field_val as *mut u64 as
+ *mut u8,
+ ::std::mem::size_of::<u64>())
+ };
+ unit_field_val &= !mask;
+ unit_field_val |= (val << 2usize) & mask;
+ unsafe {
+ ::std::ptr::copy_nonoverlapping(&unit_field_val as *const _ as
+ *const u8,
+ &mut self._bitfield_1 as *mut _ as
+ *mut u8,
+ ::std::mem::size_of::<u64>());
+ }
+ }
+ #[inline]
+ pub fn m3(&self) -> ::std::os::raw::c_char {
+ let mut unit_field_val: u64 = unsafe { ::std::mem::uninitialized() };
+ unsafe {
+ ::std::ptr::copy_nonoverlapping(&self._bitfield_1 as *const _ as
+ *const u8,
+ &mut unit_field_val as *mut u64 as
+ *mut u8,
+ ::std::mem::size_of::<u64>())
+ };
+ let mask = 8u64 as u64;
+ let val = (unit_field_val & mask) >> 3usize;
+ unsafe { ::std::mem::transmute(val as u8) }
+ }
+ #[inline]
+ pub fn set_m3(&mut self, val: ::std::os::raw::c_char) {
+ let mask = 8u64 as u64;
+ let val = val as u8 as u64;
+ let mut unit_field_val: u64 = unsafe { ::std::mem::uninitialized() };
+ unsafe {
+ ::std::ptr::copy_nonoverlapping(&self._bitfield_1 as *const _ as
+ *const u8,
+ &mut unit_field_val as *mut u64 as
+ *mut u8,
+ ::std::mem::size_of::<u64>())
+ };
+ unit_field_val &= !mask;
+ unit_field_val |= (val << 3usize) & mask;
+ unsafe {
+ ::std::ptr::copy_nonoverlapping(&unit_field_val as *const _ as
+ *const u8,
+ &mut self._bitfield_1 as *mut _ as
+ *mut u8,
+ ::std::mem::size_of::<u64>());
+ }
+ }
+ #[inline]
+ pub fn m4(&self) -> ::std::os::raw::c_char {
+ let mut unit_field_val: u64 = unsafe { ::std::mem::uninitialized() };
+ unsafe {
+ ::std::ptr::copy_nonoverlapping(&self._bitfield_1 as *const _ as
+ *const u8,
+ &mut unit_field_val as *mut u64 as
+ *mut u8,
+ ::std::mem::size_of::<u64>())
+ };
+ let mask = 16u64 as u64;
+ let val = (unit_field_val & mask) >> 4usize;
+ unsafe { ::std::mem::transmute(val as u8) }
+ }
+ #[inline]
+ pub fn set_m4(&mut self, val: ::std::os::raw::c_char) {
+ let mask = 16u64 as u64;
+ let val = val as u8 as u64;
+ let mut unit_field_val: u64 = unsafe { ::std::mem::uninitialized() };
+ unsafe {
+ ::std::ptr::copy_nonoverlapping(&self._bitfield_1 as *const _ as
+ *const u8,
+ &mut unit_field_val as *mut u64 as
+ *mut u8,
+ ::std::mem::size_of::<u64>())
+ };
+ unit_field_val &= !mask;
+ unit_field_val |= (val << 4usize) & mask;
+ unsafe {
+ ::std::ptr::copy_nonoverlapping(&unit_field_val as *const _ as
+ *const u8,
+ &mut self._bitfield_1 as *mut _ as
+ *mut u8,
+ ::std::mem::size_of::<u64>());
+ }
+ }
+ #[inline]
+ pub fn m5(&self) -> ::std::os::raw::c_char {
+ let mut unit_field_val: u64 = unsafe { ::std::mem::uninitialized() };
+ unsafe {
+ ::std::ptr::copy_nonoverlapping(&self._bitfield_1 as *const _ as
+ *const u8,
+ &mut unit_field_val as *mut u64 as
+ *mut u8,
+ ::std::mem::size_of::<u64>())
+ };
+ let mask = 32u64 as u64;
+ let val = (unit_field_val & mask) >> 5usize;
+ unsafe { ::std::mem::transmute(val as u8) }
+ }
+ #[inline]
+ pub fn set_m5(&mut self, val: ::std::os::raw::c_char) {
+ let mask = 32u64 as u64;
+ let val = val as u8 as u64;
+ let mut unit_field_val: u64 = unsafe { ::std::mem::uninitialized() };
+ unsafe {
+ ::std::ptr::copy_nonoverlapping(&self._bitfield_1 as *const _ as
+ *const u8,
+ &mut unit_field_val as *mut u64 as
+ *mut u8,
+ ::std::mem::size_of::<u64>())
+ };
+ unit_field_val &= !mask;
+ unit_field_val |= (val << 5usize) & mask;
+ unsafe {
+ ::std::ptr::copy_nonoverlapping(&unit_field_val as *const _ as
+ *const u8,
+ &mut self._bitfield_1 as *mut _ as
+ *mut u8,
+ ::std::mem::size_of::<u64>());
+ }
+ }
+ #[inline]
+ pub fn m6(&self) -> ::std::os::raw::c_char {
+ let mut unit_field_val: u64 = unsafe { ::std::mem::uninitialized() };
+ unsafe {
+ ::std::ptr::copy_nonoverlapping(&self._bitfield_1 as *const _ as
+ *const u8,
+ &mut unit_field_val as *mut u64 as
+ *mut u8,
+ ::std::mem::size_of::<u64>())
+ };
+ let mask = 64u64 as u64;
+ let val = (unit_field_val & mask) >> 6usize;
+ unsafe { ::std::mem::transmute(val as u8) }
+ }
+ #[inline]
+ pub fn set_m6(&mut self, val: ::std::os::raw::c_char) {
+ let mask = 64u64 as u64;
+ let val = val as u8 as u64;
+ let mut unit_field_val: u64 = unsafe { ::std::mem::uninitialized() };
+ unsafe {
+ ::std::ptr::copy_nonoverlapping(&self._bitfield_1 as *const _ as
+ *const u8,
+ &mut unit_field_val as *mut u64 as
+ *mut u8,
+ ::std::mem::size_of::<u64>())
+ };
+ unit_field_val &= !mask;
+ unit_field_val |= (val << 6usize) & mask;
+ unsafe {
+ ::std::ptr::copy_nonoverlapping(&unit_field_val as *const _ as
+ *const u8,
+ &mut self._bitfield_1 as *mut _ as
+ *mut u8,
+ ::std::mem::size_of::<u64>());
+ }
+ }
+ #[inline]
+ pub fn m7(&self) -> ::std::os::raw::c_char {
+ let mut unit_field_val: u64 = unsafe { ::std::mem::uninitialized() };
+ unsafe {
+ ::std::ptr::copy_nonoverlapping(&self._bitfield_1 as *const _ as
+ *const u8,
+ &mut unit_field_val as *mut u64 as
+ *mut u8,
+ ::std::mem::size_of::<u64>())
+ };
+ let mask = 128u64 as u64;
+ let val = (unit_field_val & mask) >> 7usize;
+ unsafe { ::std::mem::transmute(val as u8) }
+ }
+ #[inline]
+ pub fn set_m7(&mut self, val: ::std::os::raw::c_char) {
+ let mask = 128u64 as u64;
+ let val = val as u8 as u64;
+ let mut unit_field_val: u64 = unsafe { ::std::mem::uninitialized() };
+ unsafe {
+ ::std::ptr::copy_nonoverlapping(&self._bitfield_1 as *const _ as
+ *const u8,
+ &mut unit_field_val as *mut u64 as
+ *mut u8,
+ ::std::mem::size_of::<u64>())
+ };
+ unit_field_val &= !mask;
+ unit_field_val |= (val << 7usize) & mask;
+ unsafe {
+ ::std::ptr::copy_nonoverlapping(&unit_field_val as *const _ as
+ *const u8,
+ &mut self._bitfield_1 as *mut _ as
+ *mut u8,
+ ::std::mem::size_of::<u64>());
+ }
+ }
+ #[inline]
+ pub fn m8(&self) -> ::std::os::raw::c_char {
+ let mut unit_field_val: u64 = unsafe { ::std::mem::uninitialized() };
+ unsafe {
+ ::std::ptr::copy_nonoverlapping(&self._bitfield_1 as *const _ as
+ *const u8,
+ &mut unit_field_val as *mut u64 as
+ *mut u8,
+ ::std::mem::size_of::<u64>())
+ };
+ let mask = 256u64 as u64;
+ let val = (unit_field_val & mask) >> 8usize;
+ unsafe { ::std::mem::transmute(val as u8) }
+ }
+ #[inline]
+ pub fn set_m8(&mut self, val: ::std::os::raw::c_char) {
+ let mask = 256u64 as u64;
+ let val = val as u8 as u64;
+ let mut unit_field_val: u64 = unsafe { ::std::mem::uninitialized() };
+ unsafe {
+ ::std::ptr::copy_nonoverlapping(&self._bitfield_1 as *const _ as
+ *const u8,
+ &mut unit_field_val as *mut u64 as
+ *mut u8,
+ ::std::mem::size_of::<u64>())
+ };
+ unit_field_val &= !mask;
+ unit_field_val |= (val << 8usize) & mask;
+ unsafe {
+ ::std::ptr::copy_nonoverlapping(&unit_field_val as *const _ as
+ *const u8,
+ &mut self._bitfield_1 as *mut _ as
+ *mut u8,
+ ::std::mem::size_of::<u64>());
+ }
+ }
+ #[inline]
+ pub fn m9(&self) -> ::std::os::raw::c_char {
+ let mut unit_field_val: u64 = unsafe { ::std::mem::uninitialized() };
+ unsafe {
+ ::std::ptr::copy_nonoverlapping(&self._bitfield_1 as *const _ as
+ *const u8,
+ &mut unit_field_val as *mut u64 as
+ *mut u8,
+ ::std::mem::size_of::<u64>())
+ };
+ let mask = 512u64 as u64;
+ let val = (unit_field_val & mask) >> 9usize;
+ unsafe { ::std::mem::transmute(val as u8) }
+ }
+ #[inline]
+ pub fn set_m9(&mut self, val: ::std::os::raw::c_char) {
+ let mask = 512u64 as u64;
+ let val = val as u8 as u64;
+ let mut unit_field_val: u64 = unsafe { ::std::mem::uninitialized() };
+ unsafe {
+ ::std::ptr::copy_nonoverlapping(&self._bitfield_1 as *const _ as
+ *const u8,
+ &mut unit_field_val as *mut u64 as
+ *mut u8,
+ ::std::mem::size_of::<u64>())
+ };
+ unit_field_val &= !mask;
+ unit_field_val |= (val << 9usize) & mask;
+ unsafe {
+ ::std::ptr::copy_nonoverlapping(&unit_field_val as *const _ as
+ *const u8,
+ &mut self._bitfield_1 as *mut _ as
+ *mut u8,
+ ::std::mem::size_of::<u64>());
+ }
+ }
+ #[inline]
+ pub fn m10(&self) -> ::std::os::raw::c_char {
+ let mut unit_field_val: u64 = unsafe { ::std::mem::uninitialized() };
+ unsafe {
+ ::std::ptr::copy_nonoverlapping(&self._bitfield_1 as *const _ as
+ *const u8,
+ &mut unit_field_val as *mut u64 as
+ *mut u8,
+ ::std::mem::size_of::<u64>())
+ };
+ let mask = 1024u64 as u64;
+ let val = (unit_field_val & mask) >> 10usize;
+ unsafe { ::std::mem::transmute(val as u8) }
+ }
+ #[inline]
+ pub fn set_m10(&mut self, val: ::std::os::raw::c_char) {
+ let mask = 1024u64 as u64;
+ let val = val as u8 as u64;
+ let mut unit_field_val: u64 = unsafe { ::std::mem::uninitialized() };
+ unsafe {
+ ::std::ptr::copy_nonoverlapping(&self._bitfield_1 as *const _ as
+ *const u8,
+ &mut unit_field_val as *mut u64 as
+ *mut u8,
+ ::std::mem::size_of::<u64>())
+ };
+ unit_field_val &= !mask;
+ unit_field_val |= (val << 10usize) & mask;
+ unsafe {
+ ::std::ptr::copy_nonoverlapping(&unit_field_val as *const _ as
+ *const u8,
+ &mut self._bitfield_1 as *mut _ as
+ *mut u8,
+ ::std::mem::size_of::<u64>());
+ }
+ }
+ #[inline]
+ pub fn m11(&self) -> ::std::os::raw::c_char {
+ let mut unit_field_val: u64 = unsafe { ::std::mem::uninitialized() };
+ unsafe {
+ ::std::ptr::copy_nonoverlapping(&self._bitfield_1 as *const _ as
+ *const u8,
+ &mut unit_field_val as *mut u64 as
+ *mut u8,
+ ::std::mem::size_of::<u64>())
+ };
+ let mask = 2048u64 as u64;
+ let val = (unit_field_val & mask) >> 11usize;
+ unsafe { ::std::mem::transmute(val as u8) }
+ }
+ #[inline]
+ pub fn set_m11(&mut self, val: ::std::os::raw::c_char) {
+ let mask = 2048u64 as u64;
+ let val = val as u8 as u64;
+ let mut unit_field_val: u64 = unsafe { ::std::mem::uninitialized() };
+ unsafe {
+ ::std::ptr::copy_nonoverlapping(&self._bitfield_1 as *const _ as
+ *const u8,
+ &mut unit_field_val as *mut u64 as
+ *mut u8,
+ ::std::mem::size_of::<u64>())
+ };
+ unit_field_val &= !mask;
+ unit_field_val |= (val << 11usize) & mask;
+ unsafe {
+ ::std::ptr::copy_nonoverlapping(&unit_field_val as *const _ as
+ *const u8,
+ &mut self._bitfield_1 as *mut _ as
+ *mut u8,
+ ::std::mem::size_of::<u64>());
+ }
+ }
+ #[inline]
+ pub fn m12(&self) -> ::std::os::raw::c_char {
+ let mut unit_field_val: u64 = unsafe { ::std::mem::uninitialized() };
+ unsafe {
+ ::std::ptr::copy_nonoverlapping(&self._bitfield_1 as *const _ as
+ *const u8,
+ &mut unit_field_val as *mut u64 as
+ *mut u8,
+ ::std::mem::size_of::<u64>())
+ };
+ let mask = 4096u64 as u64;
+ let val = (unit_field_val & mask) >> 12usize;
+ unsafe { ::std::mem::transmute(val as u8) }
+ }
+ #[inline]
+ pub fn set_m12(&mut self, val: ::std::os::raw::c_char) {
+ let mask = 4096u64 as u64;
+ let val = val as u8 as u64;
+ let mut unit_field_val: u64 = unsafe { ::std::mem::uninitialized() };
+ unsafe {
+ ::std::ptr::copy_nonoverlapping(&self._bitfield_1 as *const _ as
+ *const u8,
+ &mut unit_field_val as *mut u64 as
+ *mut u8,
+ ::std::mem::size_of::<u64>())
+ };
+ unit_field_val &= !mask;
+ unit_field_val |= (val << 12usize) & mask;
+ unsafe {
+ ::std::ptr::copy_nonoverlapping(&unit_field_val as *const _ as
+ *const u8,
+ &mut self._bitfield_1 as *mut _ as
+ *mut u8,
+ ::std::mem::size_of::<u64>());
+ }
+ }
+ #[inline]
+ pub fn m13(&self) -> ::std::os::raw::c_char {
+ let mut unit_field_val: u64 = unsafe { ::std::mem::uninitialized() };
+ unsafe {
+ ::std::ptr::copy_nonoverlapping(&self._bitfield_1 as *const _ as
+ *const u8,
+ &mut unit_field_val as *mut u64 as
+ *mut u8,
+ ::std::mem::size_of::<u64>())
+ };
+ let mask = 8192u64 as u64;
+ let val = (unit_field_val & mask) >> 13usize;
+ unsafe { ::std::mem::transmute(val as u8) }
+ }
+ #[inline]
+ pub fn set_m13(&mut self, val: ::std::os::raw::c_char) {
+ let mask = 8192u64 as u64;
+ let val = val as u8 as u64;
+ let mut unit_field_val: u64 = unsafe { ::std::mem::uninitialized() };
+ unsafe {
+ ::std::ptr::copy_nonoverlapping(&self._bitfield_1 as *const _ as
+ *const u8,
+ &mut unit_field_val as *mut u64 as
+ *mut u8,
+ ::std::mem::size_of::<u64>())
+ };
+ unit_field_val &= !mask;
+ unit_field_val |= (val << 13usize) & mask;
+ unsafe {
+ ::std::ptr::copy_nonoverlapping(&unit_field_val as *const _ as
+ *const u8,
+ &mut self._bitfield_1 as *mut _ as
+ *mut u8,
+ ::std::mem::size_of::<u64>());
+ }
+ }
+ #[inline]
+ pub fn m14(&self) -> ::std::os::raw::c_char {
+ let mut unit_field_val: u64 = unsafe { ::std::mem::uninitialized() };
+ unsafe {
+ ::std::ptr::copy_nonoverlapping(&self._bitfield_1 as *const _ as
+ *const u8,
+ &mut unit_field_val as *mut u64 as
+ *mut u8,
+ ::std::mem::size_of::<u64>())
+ };
+ let mask = 16384u64 as u64;
+ let val = (unit_field_val & mask) >> 14usize;
+ unsafe { ::std::mem::transmute(val as u8) }
+ }
+ #[inline]
+ pub fn set_m14(&mut self, val: ::std::os::raw::c_char) {
+ let mask = 16384u64 as u64;
+ let val = val as u8 as u64;
+ let mut unit_field_val: u64 = unsafe { ::std::mem::uninitialized() };
+ unsafe {
+ ::std::ptr::copy_nonoverlapping(&self._bitfield_1 as *const _ as
+ *const u8,
+ &mut unit_field_val as *mut u64 as
+ *mut u8,
+ ::std::mem::size_of::<u64>())
+ };
+ unit_field_val &= !mask;
+ unit_field_val |= (val << 14usize) & mask;
+ unsafe {
+ ::std::ptr::copy_nonoverlapping(&unit_field_val as *const _ as
+ *const u8,
+ &mut self._bitfield_1 as *mut _ as
+ *mut u8,
+ ::std::mem::size_of::<u64>());
+ }
+ }
+ #[inline]
+ pub fn m15(&self) -> ::std::os::raw::c_char {
+ let mut unit_field_val: u64 = unsafe { ::std::mem::uninitialized() };
+ unsafe {
+ ::std::ptr::copy_nonoverlapping(&self._bitfield_1 as *const _ as
+ *const u8,
+ &mut unit_field_val as *mut u64 as
+ *mut u8,
+ ::std::mem::size_of::<u64>())
+ };
+ let mask = 32768u64 as u64;
+ let val = (unit_field_val & mask) >> 15usize;
+ unsafe { ::std::mem::transmute(val as u8) }
+ }
+ #[inline]
+ pub fn set_m15(&mut self, val: ::std::os::raw::c_char) {
+ let mask = 32768u64 as u64;
+ let val = val as u8 as u64;
+ let mut unit_field_val: u64 = unsafe { ::std::mem::uninitialized() };
+ unsafe {
+ ::std::ptr::copy_nonoverlapping(&self._bitfield_1 as *const _ as
+ *const u8,
+ &mut unit_field_val as *mut u64 as
+ *mut u8,
+ ::std::mem::size_of::<u64>())
+ };
+ unit_field_val &= !mask;
+ unit_field_val |= (val << 15usize) & mask;
+ unsafe {
+ ::std::ptr::copy_nonoverlapping(&unit_field_val as *const _ as
+ *const u8,
+ &mut self._bitfield_1 as *mut _ as
+ *mut u8,
+ ::std::mem::size_of::<u64>());
+ }
+ }
+ #[inline]
+ pub fn m16(&self) -> ::std::os::raw::c_char {
+ let mut unit_field_val: u64 = unsafe { ::std::mem::uninitialized() };
+ unsafe {
+ ::std::ptr::copy_nonoverlapping(&self._bitfield_1 as *const _ as
+ *const u8,
+ &mut unit_field_val as *mut u64 as
+ *mut u8,
+ ::std::mem::size_of::<u64>())
+ };
+ let mask = 65536u64 as u64;
+ let val = (unit_field_val & mask) >> 16usize;
+ unsafe { ::std::mem::transmute(val as u8) }
+ }
+ #[inline]
+ pub fn set_m16(&mut self, val: ::std::os::raw::c_char) {
+ let mask = 65536u64 as u64;
+ let val = val as u8 as u64;
+ let mut unit_field_val: u64 = unsafe { ::std::mem::uninitialized() };
+ unsafe {
+ ::std::ptr::copy_nonoverlapping(&self._bitfield_1 as *const _ as
+ *const u8,
+ &mut unit_field_val as *mut u64 as
+ *mut u8,
+ ::std::mem::size_of::<u64>())
+ };
+ unit_field_val &= !mask;
+ unit_field_val |= (val << 16usize) & mask;
+ unsafe {
+ ::std::ptr::copy_nonoverlapping(&unit_field_val as *const _ as
+ *const u8,
+ &mut self._bitfield_1 as *mut _ as
+ *mut u8,
+ ::std::mem::size_of::<u64>());
+ }
+ }
+ #[inline]
+ pub fn m17(&self) -> ::std::os::raw::c_char {
+ let mut unit_field_val: u64 = unsafe { ::std::mem::uninitialized() };
+ unsafe {
+ ::std::ptr::copy_nonoverlapping(&self._bitfield_1 as *const _ as
+ *const u8,
+ &mut unit_field_val as *mut u64 as
+ *mut u8,
+ ::std::mem::size_of::<u64>())
+ };
+ let mask = 131072u64 as u64;
+ let val = (unit_field_val & mask) >> 17usize;
+ unsafe { ::std::mem::transmute(val as u8) }
+ }
+ #[inline]
+ pub fn set_m17(&mut self, val: ::std::os::raw::c_char) {
+ let mask = 131072u64 as u64;
+ let val = val as u8 as u64;
+ let mut unit_field_val: u64 = unsafe { ::std::mem::uninitialized() };
+ unsafe {
+ ::std::ptr::copy_nonoverlapping(&self._bitfield_1 as *const _ as
+ *const u8,
+ &mut unit_field_val as *mut u64 as
+ *mut u8,
+ ::std::mem::size_of::<u64>())
+ };
+ unit_field_val &= !mask;
+ unit_field_val |= (val << 17usize) & mask;
+ unsafe {
+ ::std::ptr::copy_nonoverlapping(&unit_field_val as *const _ as
+ *const u8,
+ &mut self._bitfield_1 as *mut _ as
+ *mut u8,
+ ::std::mem::size_of::<u64>());
+ }
+ }
+ #[inline]
+ pub fn m18(&self) -> ::std::os::raw::c_char {
+ let mut unit_field_val: u64 = unsafe { ::std::mem::uninitialized() };
+ unsafe {
+ ::std::ptr::copy_nonoverlapping(&self._bitfield_1 as *const _ as
+ *const u8,
+ &mut unit_field_val as *mut u64 as
+ *mut u8,
+ ::std::mem::size_of::<u64>())
+ };
+ let mask = 262144u64 as u64;
+ let val = (unit_field_val & mask) >> 18usize;
+ unsafe { ::std::mem::transmute(val as u8) }
+ }
+ #[inline]
+ pub fn set_m18(&mut self, val: ::std::os::raw::c_char) {
+ let mask = 262144u64 as u64;
+ let val = val as u8 as u64;
+ let mut unit_field_val: u64 = unsafe { ::std::mem::uninitialized() };
+ unsafe {
+ ::std::ptr::copy_nonoverlapping(&self._bitfield_1 as *const _ as
+ *const u8,
+ &mut unit_field_val as *mut u64 as
+ *mut u8,
+ ::std::mem::size_of::<u64>())
+ };
+ unit_field_val &= !mask;
+ unit_field_val |= (val << 18usize) & mask;
+ unsafe {
+ ::std::ptr::copy_nonoverlapping(&unit_field_val as *const _ as
+ *const u8,
+ &mut self._bitfield_1 as *mut _ as
+ *mut u8,
+ ::std::mem::size_of::<u64>());
+ }
+ }
+ #[inline]
+ pub fn m19(&self) -> ::std::os::raw::c_char {
+ let mut unit_field_val: u64 = unsafe { ::std::mem::uninitialized() };
+ unsafe {
+ ::std::ptr::copy_nonoverlapping(&self._bitfield_1 as *const _ as
+ *const u8,
+ &mut unit_field_val as *mut u64 as
+ *mut u8,
+ ::std::mem::size_of::<u64>())
+ };
+ let mask = 524288u64 as u64;
+ let val = (unit_field_val & mask) >> 19usize;
+ unsafe { ::std::mem::transmute(val as u8) }
+ }
+ #[inline]
+ pub fn set_m19(&mut self, val: ::std::os::raw::c_char) {
+ let mask = 524288u64 as u64;
+ let val = val as u8 as u64;
+ let mut unit_field_val: u64 = unsafe { ::std::mem::uninitialized() };
+ unsafe {
+ ::std::ptr::copy_nonoverlapping(&self._bitfield_1 as *const _ as
+ *const u8,
+ &mut unit_field_val as *mut u64 as
+ *mut u8,
+ ::std::mem::size_of::<u64>())
+ };
+ unit_field_val &= !mask;
+ unit_field_val |= (val << 19usize) & mask;
+ unsafe {
+ ::std::ptr::copy_nonoverlapping(&unit_field_val as *const _ as
+ *const u8,
+ &mut self._bitfield_1 as *mut _ as
+ *mut u8,
+ ::std::mem::size_of::<u64>());
+ }
+ }
+ #[inline]
+ pub fn m20(&self) -> ::std::os::raw::c_char {
+ let mut unit_field_val: u64 = unsafe { ::std::mem::uninitialized() };
+ unsafe {
+ ::std::ptr::copy_nonoverlapping(&self._bitfield_1 as *const _ as
+ *const u8,
+ &mut unit_field_val as *mut u64 as
+ *mut u8,
+ ::std::mem::size_of::<u64>())
+ };
+ let mask = 1048576u64 as u64;
+ let val = (unit_field_val & mask) >> 20usize;
+ unsafe { ::std::mem::transmute(val as u8) }
+ }
+ #[inline]
+ pub fn set_m20(&mut self, val: ::std::os::raw::c_char) {
+ let mask = 1048576u64 as u64;
+ let val = val as u8 as u64;
+ let mut unit_field_val: u64 = unsafe { ::std::mem::uninitialized() };
+ unsafe {
+ ::std::ptr::copy_nonoverlapping(&self._bitfield_1 as *const _ as
+ *const u8,
+ &mut unit_field_val as *mut u64 as
+ *mut u8,
+ ::std::mem::size_of::<u64>())
+ };
+ unit_field_val &= !mask;
+ unit_field_val |= (val << 20usize) & mask;
+ unsafe {
+ ::std::ptr::copy_nonoverlapping(&unit_field_val as *const _ as
+ *const u8,
+ &mut self._bitfield_1 as *mut _ as
+ *mut u8,
+ ::std::mem::size_of::<u64>());
+ }
+ }
+ #[inline]
+ pub fn m21(&self) -> ::std::os::raw::c_char {
+ let mut unit_field_val: u64 = unsafe { ::std::mem::uninitialized() };
+ unsafe {
+ ::std::ptr::copy_nonoverlapping(&self._bitfield_1 as *const _ as
+ *const u8,
+ &mut unit_field_val as *mut u64 as
+ *mut u8,
+ ::std::mem::size_of::<u64>())
+ };
+ let mask = 2097152u64 as u64;
+ let val = (unit_field_val & mask) >> 21usize;
+ unsafe { ::std::mem::transmute(val as u8) }
+ }
+ #[inline]
+ pub fn set_m21(&mut self, val: ::std::os::raw::c_char) {
+ let mask = 2097152u64 as u64;
+ let val = val as u8 as u64;
+ let mut unit_field_val: u64 = unsafe { ::std::mem::uninitialized() };
+ unsafe {
+ ::std::ptr::copy_nonoverlapping(&self._bitfield_1 as *const _ as
+ *const u8,
+ &mut unit_field_val as *mut u64 as
+ *mut u8,
+ ::std::mem::size_of::<u64>())
+ };
+ unit_field_val &= !mask;
+ unit_field_val |= (val << 21usize) & mask;
+ unsafe {
+ ::std::ptr::copy_nonoverlapping(&unit_field_val as *const _ as
+ *const u8,
+ &mut self._bitfield_1 as *mut _ as
+ *mut u8,
+ ::std::mem::size_of::<u64>());
+ }
+ }
+ #[inline]
+ pub fn m22(&self) -> ::std::os::raw::c_char {
+ let mut unit_field_val: u64 = unsafe { ::std::mem::uninitialized() };
+ unsafe {
+ ::std::ptr::copy_nonoverlapping(&self._bitfield_1 as *const _ as
+ *const u8,
+ &mut unit_field_val as *mut u64 as
+ *mut u8,
+ ::std::mem::size_of::<u64>())
+ };
+ let mask = 4194304u64 as u64;
+ let val = (unit_field_val & mask) >> 22usize;
+ unsafe { ::std::mem::transmute(val as u8) }
+ }
+ #[inline]
+ pub fn set_m22(&mut self, val: ::std::os::raw::c_char) {
+ let mask = 4194304u64 as u64;
+ let val = val as u8 as u64;
+ let mut unit_field_val: u64 = unsafe { ::std::mem::uninitialized() };
+ unsafe {
+ ::std::ptr::copy_nonoverlapping(&self._bitfield_1 as *const _ as
+ *const u8,
+ &mut unit_field_val as *mut u64 as
+ *mut u8,
+ ::std::mem::size_of::<u64>())
+ };
+ unit_field_val &= !mask;
+ unit_field_val |= (val << 22usize) & mask;
+ unsafe {
+ ::std::ptr::copy_nonoverlapping(&unit_field_val as *const _ as
+ *const u8,
+ &mut self._bitfield_1 as *mut _ as
+ *mut u8,
+ ::std::mem::size_of::<u64>());
+ }
+ }
+ #[inline]
+ pub fn m23(&self) -> ::std::os::raw::c_char {
+ let mut unit_field_val: u64 = unsafe { ::std::mem::uninitialized() };
+ unsafe {
+ ::std::ptr::copy_nonoverlapping(&self._bitfield_1 as *const _ as
+ *const u8,
+ &mut unit_field_val as *mut u64 as
+ *mut u8,
+ ::std::mem::size_of::<u64>())
+ };
+ let mask = 8388608u64 as u64;
+ let val = (unit_field_val & mask) >> 23usize;
+ unsafe { ::std::mem::transmute(val as u8) }
+ }
+ #[inline]
+ pub fn set_m23(&mut self, val: ::std::os::raw::c_char) {
+ let mask = 8388608u64 as u64;
+ let val = val as u8 as u64;
+ let mut unit_field_val: u64 = unsafe { ::std::mem::uninitialized() };
+ unsafe {
+ ::std::ptr::copy_nonoverlapping(&self._bitfield_1 as *const _ as
+ *const u8,
+ &mut unit_field_val as *mut u64 as
+ *mut u8,
+ ::std::mem::size_of::<u64>())
+ };
+ unit_field_val &= !mask;
+ unit_field_val |= (val << 23usize) & mask;
+ unsafe {
+ ::std::ptr::copy_nonoverlapping(&unit_field_val as *const _ as
+ *const u8,
+ &mut self._bitfield_1 as *mut _ as
+ *mut u8,
+ ::std::mem::size_of::<u64>());
+ }
+ }
+ #[inline]
+ pub fn m24(&self) -> ::std::os::raw::c_char {
+ let mut unit_field_val: u64 = unsafe { ::std::mem::uninitialized() };
+ unsafe {
+ ::std::ptr::copy_nonoverlapping(&self._bitfield_1 as *const _ as
+ *const u8,
+ &mut unit_field_val as *mut u64 as
+ *mut u8,
+ ::std::mem::size_of::<u64>())
+ };
+ let mask = 16777216u64 as u64;
+ let val = (unit_field_val & mask) >> 24usize;
+ unsafe { ::std::mem::transmute(val as u8) }
+ }
+ #[inline]
+ pub fn set_m24(&mut self, val: ::std::os::raw::c_char) {
+ let mask = 16777216u64 as u64;
+ let val = val as u8 as u64;
+ let mut unit_field_val: u64 = unsafe { ::std::mem::uninitialized() };
+ unsafe {
+ ::std::ptr::copy_nonoverlapping(&self._bitfield_1 as *const _ as
+ *const u8,
+ &mut unit_field_val as *mut u64 as
+ *mut u8,
+ ::std::mem::size_of::<u64>())
+ };
+ unit_field_val &= !mask;
+ unit_field_val |= (val << 24usize) & mask;
+ unsafe {
+ ::std::ptr::copy_nonoverlapping(&unit_field_val as *const _ as
+ *const u8,
+ &mut self._bitfield_1 as *mut _ as
+ *mut u8,
+ ::std::mem::size_of::<u64>());
+ }
+ }
+ #[inline]
+ pub fn m25(&self) -> ::std::os::raw::c_char {
+ let mut unit_field_val: u64 = unsafe { ::std::mem::uninitialized() };
+ unsafe {
+ ::std::ptr::copy_nonoverlapping(&self._bitfield_1 as *const _ as
+ *const u8,
+ &mut unit_field_val as *mut u64 as
+ *mut u8,
+ ::std::mem::size_of::<u64>())
+ };
+ let mask = 33554432u64 as u64;
+ let val = (unit_field_val & mask) >> 25usize;
+ unsafe { ::std::mem::transmute(val as u8) }
+ }
+ #[inline]
+ pub fn set_m25(&mut self, val: ::std::os::raw::c_char) {
+ let mask = 33554432u64 as u64;
+ let val = val as u8 as u64;
+ let mut unit_field_val: u64 = unsafe { ::std::mem::uninitialized() };
+ unsafe {
+ ::std::ptr::copy_nonoverlapping(&self._bitfield_1 as *const _ as
+ *const u8,
+ &mut unit_field_val as *mut u64 as
+ *mut u8,
+ ::std::mem::size_of::<u64>())
+ };
+ unit_field_val &= !mask;
+ unit_field_val |= (val << 25usize) & mask;
+ unsafe {
+ ::std::ptr::copy_nonoverlapping(&unit_field_val as *const _ as
+ *const u8,
+ &mut self._bitfield_1 as *mut _ as
+ *mut u8,
+ ::std::mem::size_of::<u64>());
+ }
+ }
+ #[inline]
+ pub fn m26(&self) -> ::std::os::raw::c_char {
+ let mut unit_field_val: u64 = unsafe { ::std::mem::uninitialized() };
+ unsafe {
+ ::std::ptr::copy_nonoverlapping(&self._bitfield_1 as *const _ as
+ *const u8,
+ &mut unit_field_val as *mut u64 as
+ *mut u8,
+ ::std::mem::size_of::<u64>())
+ };
+ let mask = 67108864u64 as u64;
+ let val = (unit_field_val & mask) >> 26usize;
+ unsafe { ::std::mem::transmute(val as u8) }
+ }
+ #[inline]
+ pub fn set_m26(&mut self, val: ::std::os::raw::c_char) {
+ let mask = 67108864u64 as u64;
+ let val = val as u8 as u64;
+ let mut unit_field_val: u64 = unsafe { ::std::mem::uninitialized() };
+ unsafe {
+ ::std::ptr::copy_nonoverlapping(&self._bitfield_1 as *const _ as
+ *const u8,
+ &mut unit_field_val as *mut u64 as
+ *mut u8,
+ ::std::mem::size_of::<u64>())
+ };
+ unit_field_val &= !mask;
+ unit_field_val |= (val << 26usize) & mask;
+ unsafe {
+ ::std::ptr::copy_nonoverlapping(&unit_field_val as *const _ as
+ *const u8,
+ &mut self._bitfield_1 as *mut _ as
+ *mut u8,
+ ::std::mem::size_of::<u64>());
+ }
+ }
+ #[inline]
+ pub fn m27(&self) -> ::std::os::raw::c_char {
+ let mut unit_field_val: u64 = unsafe { ::std::mem::uninitialized() };
+ unsafe {
+ ::std::ptr::copy_nonoverlapping(&self._bitfield_1 as *const _ as
+ *const u8,
+ &mut unit_field_val as *mut u64 as
+ *mut u8,
+ ::std::mem::size_of::<u64>())
+ };
+ let mask = 134217728u64 as u64;
+ let val = (unit_field_val & mask) >> 27usize;
+ unsafe { ::std::mem::transmute(val as u8) }
+ }
+ #[inline]
+ pub fn set_m27(&mut self, val: ::std::os::raw::c_char) {
+ let mask = 134217728u64 as u64;
+ let val = val as u8 as u64;
+ let mut unit_field_val: u64 = unsafe { ::std::mem::uninitialized() };
+ unsafe {
+ ::std::ptr::copy_nonoverlapping(&self._bitfield_1 as *const _ as
+ *const u8,
+ &mut unit_field_val as *mut u64 as
+ *mut u8,
+ ::std::mem::size_of::<u64>())
+ };
+ unit_field_val &= !mask;
+ unit_field_val |= (val << 27usize) & mask;
+ unsafe {
+ ::std::ptr::copy_nonoverlapping(&unit_field_val as *const _ as
+ *const u8,
+ &mut self._bitfield_1 as *mut _ as
+ *mut u8,
+ ::std::mem::size_of::<u64>());
+ }
+ }
+ #[inline]
+ pub fn m28(&self) -> ::std::os::raw::c_char {
+ let mut unit_field_val: u64 = unsafe { ::std::mem::uninitialized() };
+ unsafe {
+ ::std::ptr::copy_nonoverlapping(&self._bitfield_1 as *const _ as
+ *const u8,
+ &mut unit_field_val as *mut u64 as
+ *mut u8,
+ ::std::mem::size_of::<u64>())
+ };
+ let mask = 268435456u64 as u64;
+ let val = (unit_field_val & mask) >> 28usize;
+ unsafe { ::std::mem::transmute(val as u8) }
+ }
+ #[inline]
+ pub fn set_m28(&mut self, val: ::std::os::raw::c_char) {
+ let mask = 268435456u64 as u64;
+ let val = val as u8 as u64;
+ let mut unit_field_val: u64 = unsafe { ::std::mem::uninitialized() };
+ unsafe {
+ ::std::ptr::copy_nonoverlapping(&self._bitfield_1 as *const _ as
+ *const u8,
+ &mut unit_field_val as *mut u64 as
+ *mut u8,
+ ::std::mem::size_of::<u64>())
+ };
+ unit_field_val &= !mask;
+ unit_field_val |= (val << 28usize) & mask;
+ unsafe {
+ ::std::ptr::copy_nonoverlapping(&unit_field_val as *const _ as
+ *const u8,
+ &mut self._bitfield_1 as *mut _ as
+ *mut u8,
+ ::std::mem::size_of::<u64>());
+ }
+ }
+ #[inline]
+ pub fn m29(&self) -> ::std::os::raw::c_char {
+ let mut unit_field_val: u64 = unsafe { ::std::mem::uninitialized() };
+ unsafe {
+ ::std::ptr::copy_nonoverlapping(&self._bitfield_1 as *const _ as
+ *const u8,
+ &mut unit_field_val as *mut u64 as
+ *mut u8,
+ ::std::mem::size_of::<u64>())
+ };
+ let mask = 536870912u64 as u64;
+ let val = (unit_field_val & mask) >> 29usize;
+ unsafe { ::std::mem::transmute(val as u8) }
+ }
+ #[inline]
+ pub fn set_m29(&mut self, val: ::std::os::raw::c_char) {
+ let mask = 536870912u64 as u64;
+ let val = val as u8 as u64;
+ let mut unit_field_val: u64 = unsafe { ::std::mem::uninitialized() };
+ unsafe {
+ ::std::ptr::copy_nonoverlapping(&self._bitfield_1 as *const _ as
+ *const u8,
+ &mut unit_field_val as *mut u64 as
+ *mut u8,
+ ::std::mem::size_of::<u64>())
+ };
+ unit_field_val &= !mask;
+ unit_field_val |= (val << 29usize) & mask;
+ unsafe {
+ ::std::ptr::copy_nonoverlapping(&unit_field_val as *const _ as
+ *const u8,
+ &mut self._bitfield_1 as *mut _ as
+ *mut u8,
+ ::std::mem::size_of::<u64>());
+ }
+ }
+ #[inline]
+ pub fn m30(&self) -> ::std::os::raw::c_char {
+ let mut unit_field_val: u64 = unsafe { ::std::mem::uninitialized() };
+ unsafe {
+ ::std::ptr::copy_nonoverlapping(&self._bitfield_1 as *const _ as
+ *const u8,
+ &mut unit_field_val as *mut u64 as
+ *mut u8,
+ ::std::mem::size_of::<u64>())
+ };
+ let mask = 1073741824u64 as u64;
+ let val = (unit_field_val & mask) >> 30usize;
+ unsafe { ::std::mem::transmute(val as u8) }
+ }
+ #[inline]
+ pub fn set_m30(&mut self, val: ::std::os::raw::c_char) {
+ let mask = 1073741824u64 as u64;
+ let val = val as u8 as u64;
+ let mut unit_field_val: u64 = unsafe { ::std::mem::uninitialized() };
+ unsafe {
+ ::std::ptr::copy_nonoverlapping(&self._bitfield_1 as *const _ as
+ *const u8,
+ &mut unit_field_val as *mut u64 as
+ *mut u8,
+ ::std::mem::size_of::<u64>())
+ };
+ unit_field_val &= !mask;
+ unit_field_val |= (val << 30usize) & mask;
+ unsafe {
+ ::std::ptr::copy_nonoverlapping(&unit_field_val as *const _ as
+ *const u8,
+ &mut self._bitfield_1 as *mut _ as
+ *mut u8,
+ ::std::mem::size_of::<u64>());
+ }
+ }
+ #[inline]
+ pub fn m31(&self) -> ::std::os::raw::c_char {
+ let mut unit_field_val: u64 = unsafe { ::std::mem::uninitialized() };
+ unsafe {
+ ::std::ptr::copy_nonoverlapping(&self._bitfield_1 as *const _ as
+ *const u8,
+ &mut unit_field_val as *mut u64 as
+ *mut u8,
+ ::std::mem::size_of::<u64>())
+ };
+ let mask = 2147483648u64 as u64;
+ let val = (unit_field_val & mask) >> 31usize;
+ unsafe { ::std::mem::transmute(val as u8) }
+ }
+ #[inline]
+ pub fn set_m31(&mut self, val: ::std::os::raw::c_char) {
+ let mask = 2147483648u64 as u64;
+ let val = val as u8 as u64;
+ let mut unit_field_val: u64 = unsafe { ::std::mem::uninitialized() };
+ unsafe {
+ ::std::ptr::copy_nonoverlapping(&self._bitfield_1 as *const _ as
+ *const u8,
+ &mut unit_field_val as *mut u64 as
+ *mut u8,
+ ::std::mem::size_of::<u64>())
+ };
+ unit_field_val &= !mask;
+ unit_field_val |= (val << 31usize) & mask;
+ unsafe {
+ ::std::ptr::copy_nonoverlapping(&unit_field_val as *const _ as
+ *const u8,
+ &mut self._bitfield_1 as *mut _ as
+ *mut u8,
+ ::std::mem::size_of::<u64>());
+ }
+ }
+ #[inline]
+ pub fn m32(&self) -> ::std::os::raw::c_char {
+ let mut unit_field_val: u64 = unsafe { ::std::mem::uninitialized() };
+ unsafe {
+ ::std::ptr::copy_nonoverlapping(&self._bitfield_1 as *const _ as
+ *const u8,
+ &mut unit_field_val as *mut u64 as
+ *mut u8,
+ ::std::mem::size_of::<u64>())
+ };
+ let mask = 4294967296u64 as u64;
+ let val = (unit_field_val & mask) >> 32usize;
+ unsafe { ::std::mem::transmute(val as u8) }
+ }
+ #[inline]
+ pub fn set_m32(&mut self, val: ::std::os::raw::c_char) {
+ let mask = 4294967296u64 as u64;
+ let val = val as u8 as u64;
+ let mut unit_field_val: u64 = unsafe { ::std::mem::uninitialized() };
+ unsafe {
+ ::std::ptr::copy_nonoverlapping(&self._bitfield_1 as *const _ as
+ *const u8,
+ &mut unit_field_val as *mut u64 as
+ *mut u8,
+ ::std::mem::size_of::<u64>())
+ };
+ unit_field_val &= !mask;
+ unit_field_val |= (val << 32usize) & mask;
+ unsafe {
+ ::std::ptr::copy_nonoverlapping(&unit_field_val as *const _ as
+ *const u8,
+ &mut self._bitfield_1 as *mut _ as
+ *mut u8,
+ ::std::mem::size_of::<u64>());
+ }
+ }
+ #[inline]
+ pub fn new_bitfield_1(m0: ::std::os::raw::c_char,
+ m1: ::std::os::raw::c_char,
+ m2: ::std::os::raw::c_char,
+ m3: ::std::os::raw::c_char,
+ m4: ::std::os::raw::c_char,
+ m5: ::std::os::raw::c_char,
+ m6: ::std::os::raw::c_char,
+ m7: ::std::os::raw::c_char,
+ m8: ::std::os::raw::c_char,
+ m9: ::std::os::raw::c_char,
+ m10: ::std::os::raw::c_char,
+ m11: ::std::os::raw::c_char,
+ m12: ::std::os::raw::c_char,
+ m13: ::std::os::raw::c_char,
+ m14: ::std::os::raw::c_char,
+ m15: ::std::os::raw::c_char,
+ m16: ::std::os::raw::c_char,
+ m17: ::std::os::raw::c_char,
+ m18: ::std::os::raw::c_char,
+ m19: ::std::os::raw::c_char,
+ m20: ::std::os::raw::c_char,
+ m21: ::std::os::raw::c_char,
+ m22: ::std::os::raw::c_char,
+ m23: ::std::os::raw::c_char,
+ m24: ::std::os::raw::c_char,
+ m25: ::std::os::raw::c_char,
+ m26: ::std::os::raw::c_char,
+ m27: ::std::os::raw::c_char,
+ m28: ::std::os::raw::c_char,
+ m29: ::std::os::raw::c_char,
+ m30: ::std::os::raw::c_char,
+ m31: ::std::os::raw::c_char,
+ m32: ::std::os::raw::c_char) -> u64 {
+ ({
+ ({
+ ({
+ ({
+ ({
+ ({
+ ({
+ ({
+ ({
+ ({
+ ({
+ ({
+ ({
+ ({
+ ({
+ ({
+ ({
+ ({
+ ({
+ ({
+ ({
+ ({
+ ({
+ ({
+ ({
+ ({
+ ({
+ ({
+ ({
+ ({
+ ({
+ ({
+ ({
+ 0
+ }
+ |
+ ((m0
+ as
+ u8
+ as
+ u64)
+ <<
+ 0usize)
+ &
+ (1u64
+ as
+ u64))
+ }
+ |
+ ((m1
+ as
+ u8
+ as
+ u64)
+ <<
+ 1usize)
+ &
+ (2u64
+ as
+ u64))
+ }
+ |
+ ((m2
+ as
+ u8
+ as
+ u64)
+ <<
+ 2usize)
+ &
+ (4u64
+ as
+ u64))
+ }
+ |
+ ((m3
+ as
+ u8
+ as
+ u64)
+ <<
+ 3usize)
+ &
+ (8u64
+ as
+ u64))
+ }
+ |
+ ((m4
+ as
+ u8
+ as
+ u64)
+ <<
+ 4usize)
+ &
+ (16u64
+ as
+ u64))
+ }
+ |
+ ((m5
+ as
+ u8
+ as
+ u64)
+ <<
+ 5usize)
+ &
+ (32u64
+ as
+ u64))
+ }
+ |
+ ((m6
+ as
+ u8
+ as
+ u64)
+ <<
+ 6usize)
+ &
+ (64u64
+ as
+ u64))
+ }
+ |
+ ((m7
+ as
+ u8
+ as
+ u64)
+ <<
+ 7usize)
+ &
+ (128u64
+ as
+ u64))
+ }
+ |
+ ((m8
+ as
+ u8
+ as
+ u64)
+ <<
+ 8usize)
+ &
+ (256u64
+ as
+ u64))
+ }
+ |
+ ((m9
+ as
+ u8
+ as
+ u64)
+ <<
+ 9usize)
+ &
+ (512u64
+ as
+ u64))
+ }
+ |
+ ((m10
+ as
+ u8
+ as
+ u64)
+ <<
+ 10usize)
+ &
+ (1024u64
+ as
+ u64))
+ }
+ |
+ ((m11
+ as
+ u8
+ as
+ u64)
+ <<
+ 11usize)
+ &
+ (2048u64
+ as
+ u64))
+ }
+ |
+ ((m12
+ as
+ u8
+ as
+ u64)
+ <<
+ 12usize)
+ &
+ (4096u64
+ as
+ u64))
+ }
+ |
+ ((m13
+ as
+ u8
+ as
+ u64)
+ <<
+ 13usize)
+ &
+ (8192u64
+ as
+ u64))
+ }
+ |
+ ((m14
+ as
+ u8
+ as
+ u64)
+ <<
+ 14usize)
+ &
+ (16384u64
+ as
+ u64))
+ }
+ |
+ ((m15
+ as
+ u8
+ as
+ u64)
+ <<
+ 15usize)
+ &
+ (32768u64
+ as
+ u64))
+ }
+ |
+ ((m16
+ as
+ u8
+ as
+ u64)
+ <<
+ 16usize)
+ &
+ (65536u64
+ as
+ u64))
+ }
+ |
+ ((m17
+ as
+ u8
+ as
+ u64)
+ <<
+ 17usize)
+ &
+ (131072u64
+ as
+ u64))
+ }
+ |
+ ((m18
+ as
+ u8
+ as
+ u64)
+ <<
+ 18usize)
+ &
+ (262144u64
+ as
+ u64))
+ } |
+ ((m19
+ as
+ u8
+ as
+ u64)
+ <<
+ 19usize)
+ &
+ (524288u64
+ as
+ u64))
+ } |
+ ((m20
+ as
+ u8
+ as
+ u64)
+ <<
+ 20usize)
+ &
+ (1048576u64
+ as
+ u64))
+ } |
+ ((m21 as
+ u8
+ as
+ u64)
+ <<
+ 21usize)
+ &
+ (2097152u64
+ as
+ u64))
+ } |
+ ((m22 as u8 as
+ u64) <<
+ 22usize) &
+ (4194304u64
+ as
+ u64))
+ } |
+ ((m23 as u8 as u64)
+ << 23usize) &
+ (8388608u64 as
+ u64))
+ } |
+ ((m24 as u8 as u64) <<
+ 24usize) &
+ (16777216u64 as u64))
+ } |
+ ((m25 as u8 as u64) <<
+ 25usize) &
+ (33554432u64 as u64))
+ } |
+ ((m26 as u8 as u64) << 26usize) &
+ (67108864u64 as u64))
+ } |
+ ((m27 as u8 as u64) << 27usize) &
+ (134217728u64 as u64))
+ } |
+ ((m28 as u8 as u64) << 28usize) &
+ (268435456u64 as u64))
+ } |
+ ((m29 as u8 as u64) << 29usize) &
+ (536870912u64 as u64))
+ } |
+ ((m30 as u8 as u64) << 30usize) &
+ (1073741824u64 as u64))
+ } | ((m31 as u8 as u64) << 31usize) & (2147483648u64 as u64))
+ } | ((m32 as u8 as u64) << 32usize) & (4294967296u64 as u64))
+ }
+}
diff --git a/tests/expectations/tests/bitfield-method-same-name.rs b/tests/expectations/tests/bitfield-method-same-name.rs
index f0ef0e31..dd6b286f 100644
--- a/tests/expectations/tests/bitfield-method-same-name.rs
+++ b/tests/expectations/tests/bitfield-method-same-name.rs
@@ -35,29 +35,46 @@ impl Clone for Foo {
impl Foo {
#[inline]
pub fn type__bindgen_bitfield(&self) -> ::std::os::raw::c_char {
- let mask = 7usize as u8;
- let unit_field_val: u8 =
- unsafe { ::std::mem::transmute(self._bitfield_1) };
+ let mut unit_field_val: u8 = unsafe { ::std::mem::uninitialized() };
+ unsafe {
+ ::std::ptr::copy_nonoverlapping(&self._bitfield_1 as *const _ as
+ *const u8,
+ &mut unit_field_val as *mut u8 as
+ *mut u8,
+ ::std::mem::size_of::<u8>())
+ };
+ let mask = 7u64 as u8;
let val = (unit_field_val & mask) >> 0usize;
unsafe { ::std::mem::transmute(val as u8) }
}
#[inline]
pub fn set_type__bindgen_bitfield(&mut self,
val: ::std::os::raw::c_char) {
- let mask = 7usize as u8;
+ let mask = 7u64 as u8;
let val = val as u8 as u8;
- let mut unit_field_val: u8 =
- unsafe { ::std::mem::transmute(self._bitfield_1) };
+ let mut unit_field_val: u8 = unsafe { ::std::mem::uninitialized() };
+ unsafe {
+ ::std::ptr::copy_nonoverlapping(&self._bitfield_1 as *const _ as
+ *const u8,
+ &mut unit_field_val as *mut u8 as
+ *mut u8,
+ ::std::mem::size_of::<u8>())
+ };
unit_field_val &= !mask;
unit_field_val |= (val << 0usize) & mask;
- self._bitfield_1 = unsafe { ::std::mem::transmute(unit_field_val) };
+ unsafe {
+ ::std::ptr::copy_nonoverlapping(&unit_field_val as *const _ as
+ *const u8,
+ &mut self._bitfield_1 as *mut _ as
+ *mut u8,
+ ::std::mem::size_of::<u8>());
+ }
}
#[inline]
pub fn new_bitfield_1(type__bindgen_bitfield: ::std::os::raw::c_char)
-> u8 {
({ 0 } |
- ((type__bindgen_bitfield as u8 as u8) << 0usize) &
- (7usize as u8))
+ ((type__bindgen_bitfield as u8 as u8) << 0usize) & (7u64 as u8))
}
#[inline]
pub unsafe fn type_(&mut self) -> ::std::os::raw::c_char {
diff --git a/tests/expectations/tests/bitfield_align.rs b/tests/expectations/tests/bitfield_align.rs
index 9b1fc603..e2db1329 100644
--- a/tests/expectations/tests/bitfield_align.rs
+++ b/tests/expectations/tests/bitfield_align.rs
@@ -33,183 +33,363 @@ impl Clone for A {
impl A {
#[inline]
pub fn b1(&self) -> ::std::os::raw::c_uint {
- let mask = 1usize as u16;
- let unit_field_val: u16 =
- unsafe { ::std::mem::transmute(self._bitfield_1) };
+ let mut unit_field_val: u16 = unsafe { ::std::mem::uninitialized() };
+ unsafe {
+ ::std::ptr::copy_nonoverlapping(&self._bitfield_1 as *const _ as
+ *const u8,
+ &mut unit_field_val as *mut u16 as
+ *mut u8,
+ ::std::mem::size_of::<u16>())
+ };
+ let mask = 1u64 as u16;
let val = (unit_field_val & mask) >> 0usize;
unsafe { ::std::mem::transmute(val as u32) }
}
#[inline]
pub fn set_b1(&mut self, val: ::std::os::raw::c_uint) {
- let mask = 1usize as u16;
+ let mask = 1u64 as u16;
let val = val as u32 as u16;
- let mut unit_field_val: u16 =
- unsafe { ::std::mem::transmute(self._bitfield_1) };
+ let mut unit_field_val: u16 = unsafe { ::std::mem::uninitialized() };
+ unsafe {
+ ::std::ptr::copy_nonoverlapping(&self._bitfield_1 as *const _ as
+ *const u8,
+ &mut unit_field_val as *mut u16 as
+ *mut u8,
+ ::std::mem::size_of::<u16>())
+ };
unit_field_val &= !mask;
unit_field_val |= (val << 0usize) & mask;
- self._bitfield_1 = unsafe { ::std::mem::transmute(unit_field_val) };
+ unsafe {
+ ::std::ptr::copy_nonoverlapping(&unit_field_val as *const _ as
+ *const u8,
+ &mut self._bitfield_1 as *mut _ as
+ *mut u8,
+ ::std::mem::size_of::<u16>());
+ }
}
#[inline]
pub fn b2(&self) -> ::std::os::raw::c_uint {
- let mask = 2usize as u16;
- let unit_field_val: u16 =
- unsafe { ::std::mem::transmute(self._bitfield_1) };
+ let mut unit_field_val: u16 = unsafe { ::std::mem::uninitialized() };
+ unsafe {
+ ::std::ptr::copy_nonoverlapping(&self._bitfield_1 as *const _ as
+ *const u8,
+ &mut unit_field_val as *mut u16 as
+ *mut u8,
+ ::std::mem::size_of::<u16>())
+ };
+ let mask = 2u64 as u16;
let val = (unit_field_val & mask) >> 1usize;
unsafe { ::std::mem::transmute(val as u32) }
}
#[inline]
pub fn set_b2(&mut self, val: ::std::os::raw::c_uint) {
- let mask = 2usize as u16;
+ let mask = 2u64 as u16;
let val = val as u32 as u16;
- let mut unit_field_val: u16 =
- unsafe { ::std::mem::transmute(self._bitfield_1) };
+ let mut unit_field_val: u16 = unsafe { ::std::mem::uninitialized() };
+ unsafe {
+ ::std::ptr::copy_nonoverlapping(&self._bitfield_1 as *const _ as
+ *const u8,
+ &mut unit_field_val as *mut u16 as
+ *mut u8,
+ ::std::mem::size_of::<u16>())
+ };
unit_field_val &= !mask;
unit_field_val |= (val << 1usize) & mask;
- self._bitfield_1 = unsafe { ::std::mem::transmute(unit_field_val) };
+ unsafe {
+ ::std::ptr::copy_nonoverlapping(&unit_field_val as *const _ as
+ *const u8,
+ &mut self._bitfield_1 as *mut _ as
+ *mut u8,
+ ::std::mem::size_of::<u16>());
+ }
}
#[inline]
pub fn b3(&self) -> ::std::os::raw::c_uint {
- let mask = 4usize as u16;
- let unit_field_val: u16 =
- unsafe { ::std::mem::transmute(self._bitfield_1) };
+ let mut unit_field_val: u16 = unsafe { ::std::mem::uninitialized() };
+ unsafe {
+ ::std::ptr::copy_nonoverlapping(&self._bitfield_1 as *const _ as
+ *const u8,
+ &mut unit_field_val as *mut u16 as
+ *mut u8,
+ ::std::mem::size_of::<u16>())
+ };
+ let mask = 4u64 as u16;
let val = (unit_field_val & mask) >> 2usize;
unsafe { ::std::mem::transmute(val as u32) }
}
#[inline]
pub fn set_b3(&mut self, val: ::std::os::raw::c_uint) {
- let mask = 4usize as u16;
+ let mask = 4u64 as u16;
let val = val as u32 as u16;
- let mut unit_field_val: u16 =
- unsafe { ::std::mem::transmute(self._bitfield_1) };
+ let mut unit_field_val: u16 = unsafe { ::std::mem::uninitialized() };
+ unsafe {
+ ::std::ptr::copy_nonoverlapping(&self._bitfield_1 as *const _ as
+ *const u8,
+ &mut unit_field_val as *mut u16 as
+ *mut u8,
+ ::std::mem::size_of::<u16>())
+ };
unit_field_val &= !mask;
unit_field_val |= (val << 2usize) & mask;
- self._bitfield_1 = unsafe { ::std::mem::transmute(unit_field_val) };
+ unsafe {
+ ::std::ptr::copy_nonoverlapping(&unit_field_val as *const _ as
+ *const u8,
+ &mut self._bitfield_1 as *mut _ as
+ *mut u8,
+ ::std::mem::size_of::<u16>());
+ }
}
#[inline]
pub fn b4(&self) -> ::std::os::raw::c_uint {
- let mask = 8usize as u16;
- let unit_field_val: u16 =
- unsafe { ::std::mem::transmute(self._bitfield_1) };
+ let mut unit_field_val: u16 = unsafe { ::std::mem::uninitialized() };
+ unsafe {
+ ::std::ptr::copy_nonoverlapping(&self._bitfield_1 as *const _ as
+ *const u8,
+ &mut unit_field_val as *mut u16 as
+ *mut u8,
+ ::std::mem::size_of::<u16>())
+ };
+ let mask = 8u64 as u16;
let val = (unit_field_val & mask) >> 3usize;
unsafe { ::std::mem::transmute(val as u32) }
}
#[inline]
pub fn set_b4(&mut self, val: ::std::os::raw::c_uint) {
- let mask = 8usize as u16;
+ let mask = 8u64 as u16;
let val = val as u32 as u16;
- let mut unit_field_val: u16 =
- unsafe { ::std::mem::transmute(self._bitfield_1) };
+ let mut unit_field_val: u16 = unsafe { ::std::mem::uninitialized() };
+ unsafe {
+ ::std::ptr::copy_nonoverlapping(&self._bitfield_1 as *const _ as
+ *const u8,
+ &mut unit_field_val as *mut u16 as
+ *mut u8,
+ ::std::mem::size_of::<u16>())
+ };
unit_field_val &= !mask;
unit_field_val |= (val << 3usize) & mask;
- self._bitfield_1 = unsafe { ::std::mem::transmute(unit_field_val) };
+ unsafe {
+ ::std::ptr::copy_nonoverlapping(&unit_field_val as *const _ as
+ *const u8,
+ &mut self._bitfield_1 as *mut _ as
+ *mut u8,
+ ::std::mem::size_of::<u16>());
+ }
}
#[inline]
pub fn b5(&self) -> ::std::os::raw::c_uint {
- let mask = 16usize as u16;
- let unit_field_val: u16 =
- unsafe { ::std::mem::transmute(self._bitfield_1) };
+ let mut unit_field_val: u16 = unsafe { ::std::mem::uninitialized() };
+ unsafe {
+ ::std::ptr::copy_nonoverlapping(&self._bitfield_1 as *const _ as
+ *const u8,
+ &mut unit_field_val as *mut u16 as
+ *mut u8,
+ ::std::mem::size_of::<u16>())
+ };
+ let mask = 16u64 as u16;
let val = (unit_field_val & mask) >> 4usize;
unsafe { ::std::mem::transmute(val as u32) }
}
#[inline]
pub fn set_b5(&mut self, val: ::std::os::raw::c_uint) {
- let mask = 16usize as u16;
+ let mask = 16u64 as u16;
let val = val as u32 as u16;
- let mut unit_field_val: u16 =
- unsafe { ::std::mem::transmute(self._bitfield_1) };
+ let mut unit_field_val: u16 = unsafe { ::std::mem::uninitialized() };
+ unsafe {
+ ::std::ptr::copy_nonoverlapping(&self._bitfield_1 as *const _ as
+ *const u8,
+ &mut unit_field_val as *mut u16 as
+ *mut u8,
+ ::std::mem::size_of::<u16>())
+ };
unit_field_val &= !mask;
unit_field_val |= (val << 4usize) & mask;
- self._bitfield_1 = unsafe { ::std::mem::transmute(unit_field_val) };
+ unsafe {
+ ::std::ptr::copy_nonoverlapping(&unit_field_val as *const _ as
+ *const u8,
+ &mut self._bitfield_1 as *mut _ as
+ *mut u8,
+ ::std::mem::size_of::<u16>());
+ }
}
#[inline]
pub fn b6(&self) -> ::std::os::raw::c_uint {
- let mask = 32usize as u16;
- let unit_field_val: u16 =
- unsafe { ::std::mem::transmute(self._bitfield_1) };
+ let mut unit_field_val: u16 = unsafe { ::std::mem::uninitialized() };
+ unsafe {
+ ::std::ptr::copy_nonoverlapping(&self._bitfield_1 as *const _ as
+ *const u8,
+ &mut unit_field_val as *mut u16 as
+ *mut u8,
+ ::std::mem::size_of::<u16>())
+ };
+ let mask = 32u64 as u16;
let val = (unit_field_val & mask) >> 5usize;
unsafe { ::std::mem::transmute(val as u32) }
}
#[inline]
pub fn set_b6(&mut self, val: ::std::os::raw::c_uint) {
- let mask = 32usize as u16;
+ let mask = 32u64 as u16;
let val = val as u32 as u16;
- let mut unit_field_val: u16 =
- unsafe { ::std::mem::transmute(self._bitfield_1) };
+ let mut unit_field_val: u16 = unsafe { ::std::mem::uninitialized() };
+ unsafe {
+ ::std::ptr::copy_nonoverlapping(&self._bitfield_1 as *const _ as
+ *const u8,
+ &mut unit_field_val as *mut u16 as
+ *mut u8,
+ ::std::mem::size_of::<u16>())
+ };
unit_field_val &= !mask;
unit_field_val |= (val << 5usize) & mask;
- self._bitfield_1 = unsafe { ::std::mem::transmute(unit_field_val) };
+ unsafe {
+ ::std::ptr::copy_nonoverlapping(&unit_field_val as *const _ as
+ *const u8,
+ &mut self._bitfield_1 as *mut _ as
+ *mut u8,
+ ::std::mem::size_of::<u16>());
+ }
}
#[inline]
pub fn b7(&self) -> ::std::os::raw::c_uint {
- let mask = 64usize as u16;
- let unit_field_val: u16 =
- unsafe { ::std::mem::transmute(self._bitfield_1) };
+ let mut unit_field_val: u16 = unsafe { ::std::mem::uninitialized() };
+ unsafe {
+ ::std::ptr::copy_nonoverlapping(&self._bitfield_1 as *const _ as
+ *const u8,
+ &mut unit_field_val as *mut u16 as
+ *mut u8,
+ ::std::mem::size_of::<u16>())
+ };
+ let mask = 64u64 as u16;
let val = (unit_field_val & mask) >> 6usize;
unsafe { ::std::mem::transmute(val as u32) }
}
#[inline]
pub fn set_b7(&mut self, val: ::std::os::raw::c_uint) {
- let mask = 64usize as u16;
+ let mask = 64u64 as u16;
let val = val as u32 as u16;
- let mut unit_field_val: u16 =
- unsafe { ::std::mem::transmute(self._bitfield_1) };
+ let mut unit_field_val: u16 = unsafe { ::std::mem::uninitialized() };
+ unsafe {
+ ::std::ptr::copy_nonoverlapping(&self._bitfield_1 as *const _ as
+ *const u8,
+ &mut unit_field_val as *mut u16 as
+ *mut u8,
+ ::std::mem::size_of::<u16>())
+ };
unit_field_val &= !mask;
unit_field_val |= (val << 6usize) & mask;
- self._bitfield_1 = unsafe { ::std::mem::transmute(unit_field_val) };
+ unsafe {
+ ::std::ptr::copy_nonoverlapping(&unit_field_val as *const _ as
+ *const u8,
+ &mut self._bitfield_1 as *mut _ as
+ *mut u8,
+ ::std::mem::size_of::<u16>());
+ }
}
#[inline]
pub fn b8(&self) -> ::std::os::raw::c_uint {
- let mask = 128usize as u16;
- let unit_field_val: u16 =
- unsafe { ::std::mem::transmute(self._bitfield_1) };
+ let mut unit_field_val: u16 = unsafe { ::std::mem::uninitialized() };
+ unsafe {
+ ::std::ptr::copy_nonoverlapping(&self._bitfield_1 as *const _ as
+ *const u8,
+ &mut unit_field_val as *mut u16 as
+ *mut u8,
+ ::std::mem::size_of::<u16>())
+ };
+ let mask = 128u64 as u16;
let val = (unit_field_val & mask) >> 7usize;
unsafe { ::std::mem::transmute(val as u32) }
}
#[inline]
pub fn set_b8(&mut self, val: ::std::os::raw::c_uint) {
- let mask = 128usize as u16;
+ let mask = 128u64 as u16;
let val = val as u32 as u16;
- let mut unit_field_val: u16 =
- unsafe { ::std::mem::transmute(self._bitfield_1) };
+ let mut unit_field_val: u16 = unsafe { ::std::mem::uninitialized() };
+ unsafe {
+ ::std::ptr::copy_nonoverlapping(&self._bitfield_1 as *const _ as
+ *const u8,
+ &mut unit_field_val as *mut u16 as
+ *mut u8,
+ ::std::mem::size_of::<u16>())
+ };
unit_field_val &= !mask;
unit_field_val |= (val << 7usize) & mask;
- self._bitfield_1 = unsafe { ::std::mem::transmute(unit_field_val) };
+ unsafe {
+ ::std::ptr::copy_nonoverlapping(&unit_field_val as *const _ as
+ *const u8,
+ &mut self._bitfield_1 as *mut _ as
+ *mut u8,
+ ::std::mem::size_of::<u16>());
+ }
}
#[inline]
pub fn b9(&self) -> ::std::os::raw::c_uint {
- let mask = 256usize as u16;
- let unit_field_val: u16 =
- unsafe { ::std::mem::transmute(self._bitfield_1) };
+ let mut unit_field_val: u16 = unsafe { ::std::mem::uninitialized() };
+ unsafe {
+ ::std::ptr::copy_nonoverlapping(&self._bitfield_1 as *const _ as
+ *const u8,
+ &mut unit_field_val as *mut u16 as
+ *mut u8,
+ ::std::mem::size_of::<u16>())
+ };
+ let mask = 256u64 as u16;
let val = (unit_field_val & mask) >> 8usize;
unsafe { ::std::mem::transmute(val as u32) }
}
#[inline]
pub fn set_b9(&mut self, val: ::std::os::raw::c_uint) {
- let mask = 256usize as u16;
+ let mask = 256u64 as u16;
let val = val as u32 as u16;
- let mut unit_field_val: u16 =
- unsafe { ::std::mem::transmute(self._bitfield_1) };
+ let mut unit_field_val: u16 = unsafe { ::std::mem::uninitialized() };
+ unsafe {
+ ::std::ptr::copy_nonoverlapping(&self._bitfield_1 as *const _ as
+ *const u8,
+ &mut unit_field_val as *mut u16 as
+ *mut u8,
+ ::std::mem::size_of::<u16>())
+ };
unit_field_val &= !mask;
unit_field_val |= (val << 8usize) & mask;
- self._bitfield_1 = unsafe { ::std::mem::transmute(unit_field_val) };
+ unsafe {
+ ::std::ptr::copy_nonoverlapping(&unit_field_val as *const _ as
+ *const u8,
+ &mut self._bitfield_1 as *mut _ as
+ *mut u8,
+ ::std::mem::size_of::<u16>());
+ }
}
#[inline]
pub fn b10(&self) -> ::std::os::raw::c_uint {
- let mask = 512usize as u16;
- let unit_field_val: u16 =
- unsafe { ::std::mem::transmute(self._bitfield_1) };
+ let mut unit_field_val: u16 = unsafe { ::std::mem::uninitialized() };
+ unsafe {
+ ::std::ptr::copy_nonoverlapping(&self._bitfield_1 as *const _ as
+ *const u8,
+ &mut unit_field_val as *mut u16 as
+ *mut u8,
+ ::std::mem::size_of::<u16>())
+ };
+ let mask = 512u64 as u16;
let val = (unit_field_val & mask) >> 9usize;
unsafe { ::std::mem::transmute(val as u32) }
}
#[inline]
pub fn set_b10(&mut self, val: ::std::os::raw::c_uint) {
- let mask = 512usize as u16;
+ let mask = 512u64 as u16;
let val = val as u32 as u16;
- let mut unit_field_val: u16 =
- unsafe { ::std::mem::transmute(self._bitfield_1) };
+ let mut unit_field_val: u16 = unsafe { ::std::mem::uninitialized() };
+ unsafe {
+ ::std::ptr::copy_nonoverlapping(&self._bitfield_1 as *const _ as
+ *const u8,
+ &mut unit_field_val as *mut u16 as
+ *mut u8,
+ ::std::mem::size_of::<u16>())
+ };
unit_field_val &= !mask;
unit_field_val |= (val << 9usize) & mask;
- self._bitfield_1 = unsafe { ::std::mem::transmute(unit_field_val) };
+ unsafe {
+ ::std::ptr::copy_nonoverlapping(&unit_field_val as *const _ as
+ *const u8,
+ &mut self._bitfield_1 as *mut _ as
+ *mut u8,
+ ::std::mem::size_of::<u16>());
+ }
}
#[inline]
pub fn new_bitfield_1(b1: ::std::os::raw::c_uint,
@@ -234,27 +414,27 @@ impl A {
({ 0 } |
((b1 as u32 as u16)
<< 0usize) &
- (1usize as u16))
+ (1u64 as u16))
} |
((b2 as u32 as u16) <<
1usize) &
- (2usize as u16))
+ (2u64 as u16))
} |
((b3 as u32 as u16) << 2usize)
- & (4usize as u16))
+ & (4u64 as u16))
} |
((b4 as u32 as u16) << 3usize) &
- (8usize as u16))
+ (8u64 as u16))
} |
((b5 as u32 as u16) << 4usize) &
- (16usize as u16))
+ (16u64 as u16))
} |
((b6 as u32 as u16) << 5usize) &
- (32usize as u16))
- } | ((b7 as u32 as u16) << 6usize) & (64usize as u16))
- } | ((b8 as u32 as u16) << 7usize) & (128usize as u16))
- } | ((b9 as u32 as u16) << 8usize) & (256usize as u16))
- } | ((b10 as u32 as u16) << 9usize) & (512usize as u16))
+ (32u64 as u16))
+ } | ((b7 as u32 as u16) << 6usize) & (64u64 as u16))
+ } | ((b8 as u32 as u16) << 7usize) & (128u64 as u16))
+ } | ((b9 as u32 as u16) << 8usize) & (256u64 as u16))
+ } | ((b10 as u32 as u16) << 9usize) & (512u64 as u16))
}
}
#[repr(C)]
@@ -276,47 +456,83 @@ impl Clone for B {
impl B {
#[inline]
pub fn foo(&self) -> ::std::os::raw::c_uint {
- let mask = 2147483647usize as u32;
- let unit_field_val: u32 =
- unsafe { ::std::mem::transmute(self._bitfield_1) };
+ let mut unit_field_val: u32 = unsafe { ::std::mem::uninitialized() };
+ unsafe {
+ ::std::ptr::copy_nonoverlapping(&self._bitfield_1 as *const _ as
+ *const u8,
+ &mut unit_field_val as *mut u32 as
+ *mut u8,
+ ::std::mem::size_of::<u32>())
+ };
+ let mask = 2147483647u64 as u32;
let val = (unit_field_val & mask) >> 0usize;
unsafe { ::std::mem::transmute(val as u32) }
}
#[inline]
pub fn set_foo(&mut self, val: ::std::os::raw::c_uint) {
- let mask = 2147483647usize as u32;
+ let mask = 2147483647u64 as u32;
let val = val as u32 as u32;
- let mut unit_field_val: u32 =
- unsafe { ::std::mem::transmute(self._bitfield_1) };
+ let mut unit_field_val: u32 = unsafe { ::std::mem::uninitialized() };
+ unsafe {
+ ::std::ptr::copy_nonoverlapping(&self._bitfield_1 as *const _ as
+ *const u8,
+ &mut unit_field_val as *mut u32 as
+ *mut u8,
+ ::std::mem::size_of::<u32>())
+ };
unit_field_val &= !mask;
unit_field_val |= (val << 0usize) & mask;
- self._bitfield_1 = unsafe { ::std::mem::transmute(unit_field_val) };
+ unsafe {
+ ::std::ptr::copy_nonoverlapping(&unit_field_val as *const _ as
+ *const u8,
+ &mut self._bitfield_1 as *mut _ as
+ *mut u8,
+ ::std::mem::size_of::<u32>());
+ }
}
#[inline]
pub fn bar(&self) -> ::std::os::raw::c_uchar {
- let mask = 2147483648usize as u32;
- let unit_field_val: u32 =
- unsafe { ::std::mem::transmute(self._bitfield_1) };
+ let mut unit_field_val: u32 = unsafe { ::std::mem::uninitialized() };
+ unsafe {
+ ::std::ptr::copy_nonoverlapping(&self._bitfield_1 as *const _ as
+ *const u8,
+ &mut unit_field_val as *mut u32 as
+ *mut u8,
+ ::std::mem::size_of::<u32>())
+ };
+ let mask = 2147483648u64 as u32;
let val = (unit_field_val & mask) >> 31usize;
unsafe { ::std::mem::transmute(val as u8) }
}
#[inline]
pub fn set_bar(&mut self, val: ::std::os::raw::c_uchar) {
- let mask = 2147483648usize as u32;
+ let mask = 2147483648u64 as u32;
let val = val as u8 as u32;
- let mut unit_field_val: u32 =
- unsafe { ::std::mem::transmute(self._bitfield_1) };
+ let mut unit_field_val: u32 = unsafe { ::std::mem::uninitialized() };
+ unsafe {
+ ::std::ptr::copy_nonoverlapping(&self._bitfield_1 as *const _ as
+ *const u8,
+ &mut unit_field_val as *mut u32 as
+ *mut u8,
+ ::std::mem::size_of::<u32>())
+ };
unit_field_val &= !mask;
unit_field_val |= (val << 31usize) & mask;
- self._bitfield_1 = unsafe { ::std::mem::transmute(unit_field_val) };
+ unsafe {
+ ::std::ptr::copy_nonoverlapping(&unit_field_val as *const _ as
+ *const u8,
+ &mut self._bitfield_1 as *mut _ as
+ *mut u8,
+ ::std::mem::size_of::<u32>());
+ }
}
#[inline]
pub fn new_bitfield_1(foo: ::std::os::raw::c_uint,
bar: ::std::os::raw::c_uchar) -> u32 {
({
({ 0 } |
- ((foo as u32 as u32) << 0usize) & (2147483647usize as u32))
- } | ((bar as u8 as u32) << 31usize) & (2147483648usize as u32))
+ ((foo as u32 as u32) << 0usize) & (2147483647u64 as u32))
+ } | ((bar as u8 as u32) << 31usize) & (2147483648u64 as u32))
}
}
#[repr(C)]
@@ -348,51 +564,88 @@ impl Clone for C {
impl C {
#[inline]
pub fn b1(&self) -> ::std::os::raw::c_uint {
- let mask = 1usize as u8;
- let unit_field_val: u8 =
- unsafe { ::std::mem::transmute(self._bitfield_1) };
+ let mut unit_field_val: u8 = unsafe { ::std::mem::uninitialized() };
+ unsafe {
+ ::std::ptr::copy_nonoverlapping(&self._bitfield_1 as *const _ as
+ *const u8,
+ &mut unit_field_val as *mut u8 as
+ *mut u8,
+ ::std::mem::size_of::<u8>())
+ };
+ let mask = 1u64 as u8;
let val = (unit_field_val & mask) >> 0usize;
unsafe { ::std::mem::transmute(val as u32) }
}
#[inline]
pub fn set_b1(&mut self, val: ::std::os::raw::c_uint) {
- let mask = 1usize as u8;
+ let mask = 1u64 as u8;
let val = val as u32 as u8;
- let mut unit_field_val: u8 =
- unsafe { ::std::mem::transmute(self._bitfield_1) };
+ let mut unit_field_val: u8 = unsafe { ::std::mem::uninitialized() };
+ unsafe {
+ ::std::ptr::copy_nonoverlapping(&self._bitfield_1 as *const _ as
+ *const u8,
+ &mut unit_field_val as *mut u8 as
+ *mut u8,
+ ::std::mem::size_of::<u8>())
+ };
unit_field_val &= !mask;
unit_field_val |= (val << 0usize) & mask;
- self._bitfield_1 = unsafe { ::std::mem::transmute(unit_field_val) };
+ unsafe {
+ ::std::ptr::copy_nonoverlapping(&unit_field_val as *const _ as
+ *const u8,
+ &mut self._bitfield_1 as *mut _ as
+ *mut u8,
+ ::std::mem::size_of::<u8>());
+ }
}
#[inline]
pub fn b2(&self) -> ::std::os::raw::c_uint {
- let mask = 2usize as u8;
- let unit_field_val: u8 =
- unsafe { ::std::mem::transmute(self._bitfield_1) };
+ let mut unit_field_val: u8 = unsafe { ::std::mem::uninitialized() };
+ unsafe {
+ ::std::ptr::copy_nonoverlapping(&self._bitfield_1 as *const _ as
+ *const u8,
+ &mut unit_field_val as *mut u8 as
+ *mut u8,
+ ::std::mem::size_of::<u8>())
+ };
+ let mask = 2u64 as u8;
let val = (unit_field_val & mask) >> 1usize;
unsafe { ::std::mem::transmute(val as u32) }
}
#[inline]
pub fn set_b2(&mut self, val: ::std::os::raw::c_uint) {
- let mask = 2usize as u8;
+ let mask = 2u64 as u8;
let val = val as u32 as u8;
- let mut unit_field_val: u8 =
- unsafe { ::std::mem::transmute(self._bitfield_1) };
+ let mut unit_field_val: u8 = unsafe { ::std::mem::uninitialized() };
+ unsafe {
+ ::std::ptr::copy_nonoverlapping(&self._bitfield_1 as *const _ as
+ *const u8,
+ &mut unit_field_val as *mut u8 as
+ *mut u8,
+ ::std::mem::size_of::<u8>())
+ };
unit_field_val &= !mask;
unit_field_val |= (val << 1usize) & mask;
- self._bitfield_1 = unsafe { ::std::mem::transmute(unit_field_val) };
+ unsafe {
+ ::std::ptr::copy_nonoverlapping(&unit_field_val as *const _ as
+ *const u8,
+ &mut self._bitfield_1 as *mut _ as
+ *mut u8,
+ ::std::mem::size_of::<u8>());
+ }
}
#[inline]
pub fn new_bitfield_1(b1: ::std::os::raw::c_uint,
b2: ::std::os::raw::c_uint) -> u8 {
- ({ ({ 0 } | ((b1 as u32 as u8) << 0usize) & (1usize as u8)) } |
- ((b2 as u32 as u8) << 1usize) & (2usize as u8))
+ ({ ({ 0 } | ((b1 as u32 as u8) << 0usize) & (1u64 as u8)) } |
+ ((b2 as u32 as u8) << 1usize) & (2u64 as u8))
}
}
#[repr(C)]
#[derive(Debug, Default, Copy)]
pub struct Date1 {
- pub _bitfield_1: [u8; 4usize],
+ pub _bitfield_1: [u8; 3usize],
+ pub __bindgen_padding_0: u8,
pub __bindgen_align: [u16; 0usize],
}
#[test]
@@ -408,75 +661,147 @@ impl Clone for Date1 {
impl Date1 {
#[inline]
pub fn nWeekDay(&self) -> ::std::os::raw::c_ushort {
- let mask = 7usize as u32;
- let unit_field_val: u32 =
- unsafe { ::std::mem::transmute(self._bitfield_1) };
+ let mut unit_field_val: u32 = unsafe { ::std::mem::uninitialized() };
+ unsafe {
+ ::std::ptr::copy_nonoverlapping(&self._bitfield_1 as *const _ as
+ *const u8,
+ &mut unit_field_val as *mut u32 as
+ *mut u8,
+ ::std::mem::size_of::<u32>())
+ };
+ let mask = 7u64 as u32;
let val = (unit_field_val & mask) >> 0usize;
unsafe { ::std::mem::transmute(val as u16) }
}
#[inline]
pub fn set_nWeekDay(&mut self, val: ::std::os::raw::c_ushort) {
- let mask = 7usize as u32;
+ let mask = 7u64 as u32;
let val = val as u16 as u32;
- let mut unit_field_val: u32 =
- unsafe { ::std::mem::transmute(self._bitfield_1) };
+ let mut unit_field_val: u32 = unsafe { ::std::mem::uninitialized() };
+ unsafe {
+ ::std::ptr::copy_nonoverlapping(&self._bitfield_1 as *const _ as
+ *const u8,
+ &mut unit_field_val as *mut u32 as
+ *mut u8,
+ ::std::mem::size_of::<u32>())
+ };
unit_field_val &= !mask;
unit_field_val |= (val << 0usize) & mask;
- self._bitfield_1 = unsafe { ::std::mem::transmute(unit_field_val) };
+ unsafe {
+ ::std::ptr::copy_nonoverlapping(&unit_field_val as *const _ as
+ *const u8,
+ &mut self._bitfield_1 as *mut _ as
+ *mut u8,
+ ::std::mem::size_of::<u32>());
+ }
}
#[inline]
pub fn nMonthDay(&self) -> ::std::os::raw::c_ushort {
- let mask = 504usize as u32;
- let unit_field_val: u32 =
- unsafe { ::std::mem::transmute(self._bitfield_1) };
+ let mut unit_field_val: u32 = unsafe { ::std::mem::uninitialized() };
+ unsafe {
+ ::std::ptr::copy_nonoverlapping(&self._bitfield_1 as *const _ as
+ *const u8,
+ &mut unit_field_val as *mut u32 as
+ *mut u8,
+ ::std::mem::size_of::<u32>())
+ };
+ let mask = 504u64 as u32;
let val = (unit_field_val & mask) >> 3usize;
unsafe { ::std::mem::transmute(val as u16) }
}
#[inline]
pub fn set_nMonthDay(&mut self, val: ::std::os::raw::c_ushort) {
- let mask = 504usize as u32;
+ let mask = 504u64 as u32;
let val = val as u16 as u32;
- let mut unit_field_val: u32 =
- unsafe { ::std::mem::transmute(self._bitfield_1) };
+ let mut unit_field_val: u32 = unsafe { ::std::mem::uninitialized() };
+ unsafe {
+ ::std::ptr::copy_nonoverlapping(&self._bitfield_1 as *const _ as
+ *const u8,
+ &mut unit_field_val as *mut u32 as
+ *mut u8,
+ ::std::mem::size_of::<u32>())
+ };
unit_field_val &= !mask;
unit_field_val |= (val << 3usize) & mask;
- self._bitfield_1 = unsafe { ::std::mem::transmute(unit_field_val) };
+ unsafe {
+ ::std::ptr::copy_nonoverlapping(&unit_field_val as *const _ as
+ *const u8,
+ &mut self._bitfield_1 as *mut _ as
+ *mut u8,
+ ::std::mem::size_of::<u32>());
+ }
}
#[inline]
pub fn nMonth(&self) -> ::std::os::raw::c_ushort {
- let mask = 15872usize as u32;
- let unit_field_val: u32 =
- unsafe { ::std::mem::transmute(self._bitfield_1) };
+ let mut unit_field_val: u32 = unsafe { ::std::mem::uninitialized() };
+ unsafe {
+ ::std::ptr::copy_nonoverlapping(&self._bitfield_1 as *const _ as
+ *const u8,
+ &mut unit_field_val as *mut u32 as
+ *mut u8,
+ ::std::mem::size_of::<u32>())
+ };
+ let mask = 15872u64 as u32;
let val = (unit_field_val & mask) >> 9usize;
unsafe { ::std::mem::transmute(val as u16) }
}
#[inline]
pub fn set_nMonth(&mut self, val: ::std::os::raw::c_ushort) {
- let mask = 15872usize as u32;
+ let mask = 15872u64 as u32;
let val = val as u16 as u32;
- let mut unit_field_val: u32 =
- unsafe { ::std::mem::transmute(self._bitfield_1) };
+ let mut unit_field_val: u32 = unsafe { ::std::mem::uninitialized() };
+ unsafe {
+ ::std::ptr::copy_nonoverlapping(&self._bitfield_1 as *const _ as
+ *const u8,
+ &mut unit_field_val as *mut u32 as
+ *mut u8,
+ ::std::mem::size_of::<u32>())
+ };
unit_field_val &= !mask;
unit_field_val |= (val << 9usize) & mask;
- self._bitfield_1 = unsafe { ::std::mem::transmute(unit_field_val) };
+ unsafe {
+ ::std::ptr::copy_nonoverlapping(&unit_field_val as *const _ as
+ *const u8,
+ &mut self._bitfield_1 as *mut _ as
+ *mut u8,
+ ::std::mem::size_of::<u32>());
+ }
}
#[inline]
pub fn nYear(&self) -> ::std::os::raw::c_ushort {
- let mask = 16711680usize as u32;
- let unit_field_val: u32 =
- unsafe { ::std::mem::transmute(self._bitfield_1) };
+ let mut unit_field_val: u32 = unsafe { ::std::mem::uninitialized() };
+ unsafe {
+ ::std::ptr::copy_nonoverlapping(&self._bitfield_1 as *const _ as
+ *const u8,
+ &mut unit_field_val as *mut u32 as
+ *mut u8,
+ ::std::mem::size_of::<u32>())
+ };
+ let mask = 16711680u64 as u32;
let val = (unit_field_val & mask) >> 16usize;
unsafe { ::std::mem::transmute(val as u16) }
}
#[inline]
pub fn set_nYear(&mut self, val: ::std::os::raw::c_ushort) {
- let mask = 16711680usize as u32;
+ let mask = 16711680u64 as u32;
let val = val as u16 as u32;
- let mut unit_field_val: u32 =
- unsafe { ::std::mem::transmute(self._bitfield_1) };
+ let mut unit_field_val: u32 = unsafe { ::std::mem::uninitialized() };
+ unsafe {
+ ::std::ptr::copy_nonoverlapping(&self._bitfield_1 as *const _ as
+ *const u8,
+ &mut unit_field_val as *mut u32 as
+ *mut u8,
+ ::std::mem::size_of::<u32>())
+ };
unit_field_val &= !mask;
unit_field_val |= (val << 16usize) & mask;
- self._bitfield_1 = unsafe { ::std::mem::transmute(unit_field_val) };
+ unsafe {
+ ::std::ptr::copy_nonoverlapping(&unit_field_val as *const _ as
+ *const u8,
+ &mut self._bitfield_1 as *mut _ as
+ *mut u8,
+ ::std::mem::size_of::<u32>());
+ }
}
#[inline]
pub fn new_bitfield_1(nWeekDay: ::std::os::raw::c_ushort,
@@ -488,12 +813,12 @@ impl Date1 {
({
({ 0 } |
((nWeekDay as u16 as u32) << 0usize) &
- (7usize as u32))
+ (7u64 as u32))
} |
((nMonthDay as u16 as u32) << 3usize) &
- (504usize as u32))
- } | ((nMonth as u16 as u32) << 9usize) & (15872usize as u32))
- } | ((nYear as u16 as u32) << 16usize) & (16711680usize as u32))
+ (504u64 as u32))
+ } | ((nMonth as u16 as u32) << 9usize) & (15872u64 as u32))
+ } | ((nYear as u16 as u32) << 16usize) & (16711680u64 as u32))
}
}
#[repr(C)]
@@ -515,93 +840,183 @@ impl Clone for Date2 {
impl Date2 {
#[inline]
pub fn nWeekDay(&self) -> ::std::os::raw::c_ushort {
- let mask = 7usize as u32;
- let unit_field_val: u32 =
- unsafe { ::std::mem::transmute(self._bitfield_1) };
+ let mut unit_field_val: u32 = unsafe { ::std::mem::uninitialized() };
+ unsafe {
+ ::std::ptr::copy_nonoverlapping(&self._bitfield_1 as *const _ as
+ *const u8,
+ &mut unit_field_val as *mut u32 as
+ *mut u8,
+ ::std::mem::size_of::<u32>())
+ };
+ let mask = 7u64 as u32;
let val = (unit_field_val & mask) >> 0usize;
unsafe { ::std::mem::transmute(val as u16) }
}
#[inline]
pub fn set_nWeekDay(&mut self, val: ::std::os::raw::c_ushort) {
- let mask = 7usize as u32;
+ let mask = 7u64 as u32;
let val = val as u16 as u32;
- let mut unit_field_val: u32 =
- unsafe { ::std::mem::transmute(self._bitfield_1) };
+ let mut unit_field_val: u32 = unsafe { ::std::mem::uninitialized() };
+ unsafe {
+ ::std::ptr::copy_nonoverlapping(&self._bitfield_1 as *const _ as
+ *const u8,
+ &mut unit_field_val as *mut u32 as
+ *mut u8,
+ ::std::mem::size_of::<u32>())
+ };
unit_field_val &= !mask;
unit_field_val |= (val << 0usize) & mask;
- self._bitfield_1 = unsafe { ::std::mem::transmute(unit_field_val) };
+ unsafe {
+ ::std::ptr::copy_nonoverlapping(&unit_field_val as *const _ as
+ *const u8,
+ &mut self._bitfield_1 as *mut _ as
+ *mut u8,
+ ::std::mem::size_of::<u32>());
+ }
}
#[inline]
pub fn nMonthDay(&self) -> ::std::os::raw::c_ushort {
- let mask = 504usize as u32;
- let unit_field_val: u32 =
- unsafe { ::std::mem::transmute(self._bitfield_1) };
+ let mut unit_field_val: u32 = unsafe { ::std::mem::uninitialized() };
+ unsafe {
+ ::std::ptr::copy_nonoverlapping(&self._bitfield_1 as *const _ as
+ *const u8,
+ &mut unit_field_val as *mut u32 as
+ *mut u8,
+ ::std::mem::size_of::<u32>())
+ };
+ let mask = 504u64 as u32;
let val = (unit_field_val & mask) >> 3usize;
unsafe { ::std::mem::transmute(val as u16) }
}
#[inline]
pub fn set_nMonthDay(&mut self, val: ::std::os::raw::c_ushort) {
- let mask = 504usize as u32;
+ let mask = 504u64 as u32;
let val = val as u16 as u32;
- let mut unit_field_val: u32 =
- unsafe { ::std::mem::transmute(self._bitfield_1) };
+ let mut unit_field_val: u32 = unsafe { ::std::mem::uninitialized() };
+ unsafe {
+ ::std::ptr::copy_nonoverlapping(&self._bitfield_1 as *const _ as
+ *const u8,
+ &mut unit_field_val as *mut u32 as
+ *mut u8,
+ ::std::mem::size_of::<u32>())
+ };
unit_field_val &= !mask;
unit_field_val |= (val << 3usize) & mask;
- self._bitfield_1 = unsafe { ::std::mem::transmute(unit_field_val) };
+ unsafe {
+ ::std::ptr::copy_nonoverlapping(&unit_field_val as *const _ as
+ *const u8,
+ &mut self._bitfield_1 as *mut _ as
+ *mut u8,
+ ::std::mem::size_of::<u32>());
+ }
}
#[inline]
pub fn nMonth(&self) -> ::std::os::raw::c_ushort {
- let mask = 15872usize as u32;
- let unit_field_val: u32 =
- unsafe { ::std::mem::transmute(self._bitfield_1) };
+ let mut unit_field_val: u32 = unsafe { ::std::mem::uninitialized() };
+ unsafe {
+ ::std::ptr::copy_nonoverlapping(&self._bitfield_1 as *const _ as
+ *const u8,
+ &mut unit_field_val as *mut u32 as
+ *mut u8,
+ ::std::mem::size_of::<u32>())
+ };
+ let mask = 15872u64 as u32;
let val = (unit_field_val & mask) >> 9usize;
unsafe { ::std::mem::transmute(val as u16) }
}
#[inline]
pub fn set_nMonth(&mut self, val: ::std::os::raw::c_ushort) {
- let mask = 15872usize as u32;
+ let mask = 15872u64 as u32;
let val = val as u16 as u32;
- let mut unit_field_val: u32 =
- unsafe { ::std::mem::transmute(self._bitfield_1) };
+ let mut unit_field_val: u32 = unsafe { ::std::mem::uninitialized() };
+ unsafe {
+ ::std::ptr::copy_nonoverlapping(&self._bitfield_1 as *const _ as
+ *const u8,
+ &mut unit_field_val as *mut u32 as
+ *mut u8,
+ ::std::mem::size_of::<u32>())
+ };
unit_field_val &= !mask;
unit_field_val |= (val << 9usize) & mask;
- self._bitfield_1 = unsafe { ::std::mem::transmute(unit_field_val) };
+ unsafe {
+ ::std::ptr::copy_nonoverlapping(&unit_field_val as *const _ as
+ *const u8,
+ &mut self._bitfield_1 as *mut _ as
+ *mut u8,
+ ::std::mem::size_of::<u32>());
+ }
}
#[inline]
pub fn nYear(&self) -> ::std::os::raw::c_ushort {
- let mask = 16711680usize as u32;
- let unit_field_val: u32 =
- unsafe { ::std::mem::transmute(self._bitfield_1) };
+ let mut unit_field_val: u32 = unsafe { ::std::mem::uninitialized() };
+ unsafe {
+ ::std::ptr::copy_nonoverlapping(&self._bitfield_1 as *const _ as
+ *const u8,
+ &mut unit_field_val as *mut u32 as
+ *mut u8,
+ ::std::mem::size_of::<u32>())
+ };
+ let mask = 16711680u64 as u32;
let val = (unit_field_val & mask) >> 16usize;
unsafe { ::std::mem::transmute(val as u16) }
}
#[inline]
pub fn set_nYear(&mut self, val: ::std::os::raw::c_ushort) {
- let mask = 16711680usize as u32;
+ let mask = 16711680u64 as u32;
let val = val as u16 as u32;
- let mut unit_field_val: u32 =
- unsafe { ::std::mem::transmute(self._bitfield_1) };
+ let mut unit_field_val: u32 = unsafe { ::std::mem::uninitialized() };
+ unsafe {
+ ::std::ptr::copy_nonoverlapping(&self._bitfield_1 as *const _ as
+ *const u8,
+ &mut unit_field_val as *mut u32 as
+ *mut u8,
+ ::std::mem::size_of::<u32>())
+ };
unit_field_val &= !mask;
unit_field_val |= (val << 16usize) & mask;
- self._bitfield_1 = unsafe { ::std::mem::transmute(unit_field_val) };
+ unsafe {
+ ::std::ptr::copy_nonoverlapping(&unit_field_val as *const _ as
+ *const u8,
+ &mut self._bitfield_1 as *mut _ as
+ *mut u8,
+ ::std::mem::size_of::<u32>());
+ }
}
#[inline]
pub fn byte(&self) -> ::std::os::raw::c_uchar {
- let mask = 4278190080usize as u32;
- let unit_field_val: u32 =
- unsafe { ::std::mem::transmute(self._bitfield_1) };
+ let mut unit_field_val: u32 = unsafe { ::std::mem::uninitialized() };
+ unsafe {
+ ::std::ptr::copy_nonoverlapping(&self._bitfield_1 as *const _ as
+ *const u8,
+ &mut unit_field_val as *mut u32 as
+ *mut u8,
+ ::std::mem::size_of::<u32>())
+ };
+ let mask = 4278190080u64 as u32;
let val = (unit_field_val & mask) >> 24usize;
unsafe { ::std::mem::transmute(val as u8) }
}
#[inline]
pub fn set_byte(&mut self, val: ::std::os::raw::c_uchar) {
- let mask = 4278190080usize as u32;
+ let mask = 4278190080u64 as u32;
let val = val as u8 as u32;
- let mut unit_field_val: u32 =
- unsafe { ::std::mem::transmute(self._bitfield_1) };
+ let mut unit_field_val: u32 = unsafe { ::std::mem::uninitialized() };
+ unsafe {
+ ::std::ptr::copy_nonoverlapping(&self._bitfield_1 as *const _ as
+ *const u8,
+ &mut unit_field_val as *mut u32 as
+ *mut u8,
+ ::std::mem::size_of::<u32>())
+ };
unit_field_val &= !mask;
unit_field_val |= (val << 24usize) & mask;
- self._bitfield_1 = unsafe { ::std::mem::transmute(unit_field_val) };
+ unsafe {
+ ::std::ptr::copy_nonoverlapping(&unit_field_val as *const _ as
+ *const u8,
+ &mut self._bitfield_1 as *mut _ as
+ *mut u8,
+ ::std::mem::size_of::<u32>());
+ }
}
#[inline]
pub fn new_bitfield_1(nWeekDay: ::std::os::raw::c_ushort,
@@ -615,14 +1030,197 @@ impl Date2 {
({
({ 0 } |
((nWeekDay as u16 as u32) << 0usize) &
- (7usize as u32))
+ (7u64 as u32))
} |
((nMonthDay as u16 as u32) << 3usize) &
- (504usize as u32))
+ (504u64 as u32))
+ } | ((nMonth as u16 as u32) << 9usize) & (15872u64 as u32))
+ } | ((nYear as u16 as u32) << 16usize) & (16711680u64 as u32))
+ } | ((byte as u8 as u32) << 24usize) & (4278190080u64 as u32))
+ }
+}
+#[repr(C)]
+#[derive(Debug, Default, Copy)]
+pub struct Date3 {
+ pub _bitfield_1: [u8; 3usize],
+ pub byte: ::std::os::raw::c_uchar,
+ pub __bindgen_align: [u16; 0usize],
+}
+#[test]
+fn bindgen_test_layout_Date3() {
+ assert_eq!(::std::mem::size_of::<Date3>() , 4usize , concat ! (
+ "Size of: " , stringify ! ( Date3 ) ));
+ assert_eq! (::std::mem::align_of::<Date3>() , 2usize , concat ! (
+ "Alignment of " , stringify ! ( Date3 ) ));
+ assert_eq! (unsafe {
+ & ( * ( 0 as * const Date3 ) ) . byte as * const _ as usize }
+ , 3usize , concat ! (
+ "Alignment of field: " , stringify ! ( Date3 ) , "::" ,
+ stringify ! ( byte ) ));
+}
+impl Clone for Date3 {
+ fn clone(&self) -> Self { *self }
+}
+impl Date3 {
+ #[inline]
+ pub fn nWeekDay(&self) -> ::std::os::raw::c_ushort {
+ let mut unit_field_val: u32 = unsafe { ::std::mem::uninitialized() };
+ unsafe {
+ ::std::ptr::copy_nonoverlapping(&self._bitfield_1 as *const _ as
+ *const u8,
+ &mut unit_field_val as *mut u32 as
+ *mut u8,
+ ::std::mem::size_of::<u32>())
+ };
+ let mask = 7u64 as u32;
+ let val = (unit_field_val & mask) >> 0usize;
+ unsafe { ::std::mem::transmute(val as u16) }
+ }
+ #[inline]
+ pub fn set_nWeekDay(&mut self, val: ::std::os::raw::c_ushort) {
+ let mask = 7u64 as u32;
+ let val = val as u16 as u32;
+ let mut unit_field_val: u32 = unsafe { ::std::mem::uninitialized() };
+ unsafe {
+ ::std::ptr::copy_nonoverlapping(&self._bitfield_1 as *const _ as
+ *const u8,
+ &mut unit_field_val as *mut u32 as
+ *mut u8,
+ ::std::mem::size_of::<u32>())
+ };
+ unit_field_val &= !mask;
+ unit_field_val |= (val << 0usize) & mask;
+ unsafe {
+ ::std::ptr::copy_nonoverlapping(&unit_field_val as *const _ as
+ *const u8,
+ &mut self._bitfield_1 as *mut _ as
+ *mut u8,
+ ::std::mem::size_of::<u32>());
+ }
+ }
+ #[inline]
+ pub fn nMonthDay(&self) -> ::std::os::raw::c_ushort {
+ let mut unit_field_val: u32 = unsafe { ::std::mem::uninitialized() };
+ unsafe {
+ ::std::ptr::copy_nonoverlapping(&self._bitfield_1 as *const _ as
+ *const u8,
+ &mut unit_field_val as *mut u32 as
+ *mut u8,
+ ::std::mem::size_of::<u32>())
+ };
+ let mask = 504u64 as u32;
+ let val = (unit_field_val & mask) >> 3usize;
+ unsafe { ::std::mem::transmute(val as u16) }
+ }
+ #[inline]
+ pub fn set_nMonthDay(&mut self, val: ::std::os::raw::c_ushort) {
+ let mask = 504u64 as u32;
+ let val = val as u16 as u32;
+ let mut unit_field_val: u32 = unsafe { ::std::mem::uninitialized() };
+ unsafe {
+ ::std::ptr::copy_nonoverlapping(&self._bitfield_1 as *const _ as
+ *const u8,
+ &mut unit_field_val as *mut u32 as
+ *mut u8,
+ ::std::mem::size_of::<u32>())
+ };
+ unit_field_val &= !mask;
+ unit_field_val |= (val << 3usize) & mask;
+ unsafe {
+ ::std::ptr::copy_nonoverlapping(&unit_field_val as *const _ as
+ *const u8,
+ &mut self._bitfield_1 as *mut _ as
+ *mut u8,
+ ::std::mem::size_of::<u32>());
+ }
+ }
+ #[inline]
+ pub fn nMonth(&self) -> ::std::os::raw::c_ushort {
+ let mut unit_field_val: u32 = unsafe { ::std::mem::uninitialized() };
+ unsafe {
+ ::std::ptr::copy_nonoverlapping(&self._bitfield_1 as *const _ as
+ *const u8,
+ &mut unit_field_val as *mut u32 as
+ *mut u8,
+ ::std::mem::size_of::<u32>())
+ };
+ let mask = 15872u64 as u32;
+ let val = (unit_field_val & mask) >> 9usize;
+ unsafe { ::std::mem::transmute(val as u16) }
+ }
+ #[inline]
+ pub fn set_nMonth(&mut self, val: ::std::os::raw::c_ushort) {
+ let mask = 15872u64 as u32;
+ let val = val as u16 as u32;
+ let mut unit_field_val: u32 = unsafe { ::std::mem::uninitialized() };
+ unsafe {
+ ::std::ptr::copy_nonoverlapping(&self._bitfield_1 as *const _ as
+ *const u8,
+ &mut unit_field_val as *mut u32 as
+ *mut u8,
+ ::std::mem::size_of::<u32>())
+ };
+ unit_field_val &= !mask;
+ unit_field_val |= (val << 9usize) & mask;
+ unsafe {
+ ::std::ptr::copy_nonoverlapping(&unit_field_val as *const _ as
+ *const u8,
+ &mut self._bitfield_1 as *mut _ as
+ *mut u8,
+ ::std::mem::size_of::<u32>());
+ }
+ }
+ #[inline]
+ pub fn nYear(&self) -> ::std::os::raw::c_ushort {
+ let mut unit_field_val: u32 = unsafe { ::std::mem::uninitialized() };
+ unsafe {
+ ::std::ptr::copy_nonoverlapping(&self._bitfield_1 as *const _ as
+ *const u8,
+ &mut unit_field_val as *mut u32 as
+ *mut u8,
+ ::std::mem::size_of::<u32>())
+ };
+ let mask = 16711680u64 as u32;
+ let val = (unit_field_val & mask) >> 16usize;
+ unsafe { ::std::mem::transmute(val as u16) }
+ }
+ #[inline]
+ pub fn set_nYear(&mut self, val: ::std::os::raw::c_ushort) {
+ let mask = 16711680u64 as u32;
+ let val = val as u16 as u32;
+ let mut unit_field_val: u32 = unsafe { ::std::mem::uninitialized() };
+ unsafe {
+ ::std::ptr::copy_nonoverlapping(&self._bitfield_1 as *const _ as
+ *const u8,
+ &mut unit_field_val as *mut u32 as
+ *mut u8,
+ ::std::mem::size_of::<u32>())
+ };
+ unit_field_val &= !mask;
+ unit_field_val |= (val << 16usize) & mask;
+ unsafe {
+ ::std::ptr::copy_nonoverlapping(&unit_field_val as *const _ as
+ *const u8,
+ &mut self._bitfield_1 as *mut _ as
+ *mut u8,
+ ::std::mem::size_of::<u32>());
+ }
+ }
+ #[inline]
+ pub fn new_bitfield_1(nWeekDay: ::std::os::raw::c_ushort,
+ nMonthDay: ::std::os::raw::c_ushort,
+ nMonth: ::std::os::raw::c_ushort,
+ nYear: ::std::os::raw::c_ushort) -> u32 {
+ ({
+ ({
+ ({
+ ({ 0 } |
+ ((nWeekDay as u16 as u32) << 0usize) &
+ (7u64 as u32))
} |
- ((nMonth as u16 as u32) << 9usize) &
- (15872usize as u32))
- } | ((nYear as u16 as u32) << 16usize) & (16711680usize as u32))
- } | ((byte as u8 as u32) << 24usize) & (4278190080usize as u32))
+ ((nMonthDay as u16 as u32) << 3usize) &
+ (504u64 as u32))
+ } | ((nMonth as u16 as u32) << 9usize) & (15872u64 as u32))
+ } | ((nYear as u16 as u32) << 16usize) & (16711680u64 as u32))
}
}
diff --git a/tests/expectations/tests/bitfield_align_2.rs b/tests/expectations/tests/bitfield_align_2.rs
index f406948c..f92f09db 100644
--- a/tests/expectations/tests/bitfield_align_2.rs
+++ b/tests/expectations/tests/bitfield_align_2.rs
@@ -29,44 +29,80 @@ impl Default for TaggedPtr {
impl TaggedPtr {
#[inline]
pub fn tag(&self) -> MyEnum {
- let mask = 3usize as u64;
- let unit_field_val: u64 =
- unsafe { ::std::mem::transmute(self._bitfield_1) };
+ let mut unit_field_val: u64 = unsafe { ::std::mem::uninitialized() };
+ unsafe {
+ ::std::ptr::copy_nonoverlapping(&self._bitfield_1 as *const _ as
+ *const u8,
+ &mut unit_field_val as *mut u64 as
+ *mut u8,
+ ::std::mem::size_of::<u64>())
+ };
+ let mask = 3u64 as u64;
let val = (unit_field_val & mask) >> 0usize;
unsafe { ::std::mem::transmute(val as u32) }
}
#[inline]
pub fn set_tag(&mut self, val: MyEnum) {
- let mask = 3usize as u64;
+ let mask = 3u64 as u64;
let val = val as u32 as u64;
- let mut unit_field_val: u64 =
- unsafe { ::std::mem::transmute(self._bitfield_1) };
+ let mut unit_field_val: u64 = unsafe { ::std::mem::uninitialized() };
+ unsafe {
+ ::std::ptr::copy_nonoverlapping(&self._bitfield_1 as *const _ as
+ *const u8,
+ &mut unit_field_val as *mut u64 as
+ *mut u8,
+ ::std::mem::size_of::<u64>())
+ };
unit_field_val &= !mask;
unit_field_val |= (val << 0usize) & mask;
- self._bitfield_1 = unsafe { ::std::mem::transmute(unit_field_val) };
+ unsafe {
+ ::std::ptr::copy_nonoverlapping(&unit_field_val as *const _ as
+ *const u8,
+ &mut self._bitfield_1 as *mut _ as
+ *mut u8,
+ ::std::mem::size_of::<u64>());
+ }
}
#[inline]
pub fn ptr(&self) -> ::std::os::raw::c_long {
- let mask = 18446744073709551612usize as u64;
- let unit_field_val: u64 =
- unsafe { ::std::mem::transmute(self._bitfield_1) };
+ let mut unit_field_val: u64 = unsafe { ::std::mem::uninitialized() };
+ unsafe {
+ ::std::ptr::copy_nonoverlapping(&self._bitfield_1 as *const _ as
+ *const u8,
+ &mut unit_field_val as *mut u64 as
+ *mut u8,
+ ::std::mem::size_of::<u64>())
+ };
+ let mask = 18446744073709551612u64 as u64;
let val = (unit_field_val & mask) >> 2usize;
unsafe { ::std::mem::transmute(val as u64) }
}
#[inline]
pub fn set_ptr(&mut self, val: ::std::os::raw::c_long) {
- let mask = 18446744073709551612usize as u64;
+ let mask = 18446744073709551612u64 as u64;
let val = val as u64 as u64;
- let mut unit_field_val: u64 =
- unsafe { ::std::mem::transmute(self._bitfield_1) };
+ let mut unit_field_val: u64 = unsafe { ::std::mem::uninitialized() };
+ unsafe {
+ ::std::ptr::copy_nonoverlapping(&self._bitfield_1 as *const _ as
+ *const u8,
+ &mut unit_field_val as *mut u64 as
+ *mut u8,
+ ::std::mem::size_of::<u64>())
+ };
unit_field_val &= !mask;
unit_field_val |= (val << 2usize) & mask;
- self._bitfield_1 = unsafe { ::std::mem::transmute(unit_field_val) };
+ unsafe {
+ ::std::ptr::copy_nonoverlapping(&unit_field_val as *const _ as
+ *const u8,
+ &mut self._bitfield_1 as *mut _ as
+ *mut u8,
+ ::std::mem::size_of::<u64>());
+ }
}
#[inline]
pub fn new_bitfield_1(tag: MyEnum, ptr: ::std::os::raw::c_long) -> u64 {
- ({ ({ 0 } | ((tag as u32 as u64) << 0usize) & (3usize as u64)) } |
+ ({ ({ 0 } | ((tag as u32 as u64) << 0usize) & (3u64 as u64)) } |
((ptr as u64 as u64) << 2usize) &
- (18446744073709551612usize as u64))
+ (18446744073709551612u64 as u64))
}
}
diff --git a/tests/expectations/tests/bitfield_method_mangling.rs b/tests/expectations/tests/bitfield_method_mangling.rs
index 314121a9..855ae72b 100644
--- a/tests/expectations/tests/bitfield_method_mangling.rs
+++ b/tests/expectations/tests/bitfield_method_mangling.rs
@@ -26,46 +26,80 @@ impl Clone for mach_msg_type_descriptor_t {
impl mach_msg_type_descriptor_t {
#[inline]
pub fn pad3(&self) -> ::std::os::raw::c_uint {
- let mask = 16777215usize as u32;
- let unit_field_val: u32 =
- unsafe { ::std::mem::transmute(self._bitfield_1) };
+ let mut unit_field_val: u32 = unsafe { ::std::mem::uninitialized() };
+ unsafe {
+ ::std::ptr::copy_nonoverlapping(&self._bitfield_1 as *const _ as
+ *const u8,
+ &mut unit_field_val as *mut u32 as
+ *mut u8,
+ ::std::mem::size_of::<u32>())
+ };
+ let mask = 16777215u64 as u32;
let val = (unit_field_val & mask) >> 0usize;
unsafe { ::std::mem::transmute(val as u32) }
}
#[inline]
pub fn set_pad3(&mut self, val: ::std::os::raw::c_uint) {
- let mask = 16777215usize as u32;
+ let mask = 16777215u64 as u32;
let val = val as u32 as u32;
- let mut unit_field_val: u32 =
- unsafe { ::std::mem::transmute(self._bitfield_1) };
+ let mut unit_field_val: u32 = unsafe { ::std::mem::uninitialized() };
+ unsafe {
+ ::std::ptr::copy_nonoverlapping(&self._bitfield_1 as *const _ as
+ *const u8,
+ &mut unit_field_val as *mut u32 as
+ *mut u8,
+ ::std::mem::size_of::<u32>())
+ };
unit_field_val &= !mask;
unit_field_val |= (val << 0usize) & mask;
- self._bitfield_1 = unsafe { ::std::mem::transmute(unit_field_val) };
+ unsafe {
+ ::std::ptr::copy_nonoverlapping(&unit_field_val as *const _ as
+ *const u8,
+ &mut self._bitfield_1 as *mut _ as
+ *mut u8,
+ ::std::mem::size_of::<u32>());
+ }
}
#[inline]
pub fn type_(&self) -> ::std::os::raw::c_uint {
- let mask = 4278190080usize as u32;
- let unit_field_val: u32 =
- unsafe { ::std::mem::transmute(self._bitfield_1) };
+ let mut unit_field_val: u32 = unsafe { ::std::mem::uninitialized() };
+ unsafe {
+ ::std::ptr::copy_nonoverlapping(&self._bitfield_1 as *const _ as
+ *const u8,
+ &mut unit_field_val as *mut u32 as
+ *mut u8,
+ ::std::mem::size_of::<u32>())
+ };
+ let mask = 4278190080u64 as u32;
let val = (unit_field_val & mask) >> 24usize;
unsafe { ::std::mem::transmute(val as u32) }
}
#[inline]
pub fn set_type(&mut self, val: ::std::os::raw::c_uint) {
- let mask = 4278190080usize as u32;
+ let mask = 4278190080u64 as u32;
let val = val as u32 as u32;
- let mut unit_field_val: u32 =
- unsafe { ::std::mem::transmute(self._bitfield_1) };
+ let mut unit_field_val: u32 = unsafe { ::std::mem::uninitialized() };
+ unsafe {
+ ::std::ptr::copy_nonoverlapping(&self._bitfield_1 as *const _ as
+ *const u8,
+ &mut unit_field_val as *mut u32 as
+ *mut u8,
+ ::std::mem::size_of::<u32>())
+ };
unit_field_val &= !mask;
unit_field_val |= (val << 24usize) & mask;
- self._bitfield_1 = unsafe { ::std::mem::transmute(unit_field_val) };
+ unsafe {
+ ::std::ptr::copy_nonoverlapping(&unit_field_val as *const _ as
+ *const u8,
+ &mut self._bitfield_1 as *mut _ as
+ *mut u8,
+ ::std::mem::size_of::<u32>());
+ }
}
#[inline]
pub fn new_bitfield_1(pad3: ::std::os::raw::c_uint,
type_: ::std::os::raw::c_uint) -> u32 {
- ({
- ({ 0 } |
- ((pad3 as u32 as u32) << 0usize) & (16777215usize as u32))
- } | ((type_ as u32 as u32) << 24usize) & (4278190080usize as u32))
+ ({ ({ 0 } | ((pad3 as u32 as u32) << 0usize) & (16777215u64 as u32)) }
+ | ((type_ as u32 as u32) << 24usize) & (4278190080u64 as u32))
}
}
diff --git a/tests/expectations/tests/class_nested.rs b/tests/expectations/tests/class_nested.rs
index 5ab0c918..d5f4e1a9 100644
--- a/tests/expectations/tests/class_nested.rs
+++ b/tests/expectations/tests/class_nested.rs
@@ -78,7 +78,7 @@ extern "C" {
pub static mut var: A_B;
}
#[test]
-fn __bindgen_test_layout_A_D_instantiation_1() {
+fn __bindgen_test_layout_A_D_instantiation() {
assert_eq!(::std::mem::size_of::<A_D<::std::os::raw::c_int>>() , 4usize ,
concat ! (
"Size of template specialization: " , stringify ! (
diff --git a/tests/expectations/tests/class_with_dtor.rs b/tests/expectations/tests/class_with_dtor.rs
index c3cd31f2..d291a983 100644
--- a/tests/expectations/tests/class_with_dtor.rs
+++ b/tests/expectations/tests/class_with_dtor.rs
@@ -35,7 +35,7 @@ impl Default for WithoutDtor {
fn default() -> Self { unsafe { ::std::mem::zeroed() } }
}
#[test]
-fn __bindgen_test_layout_HandleWithDtor_instantiation_1() {
+fn __bindgen_test_layout_HandleWithDtor_instantiation() {
assert_eq!(::std::mem::size_of::<HandleWithDtor<::std::os::raw::c_int>>()
, 8usize , concat ! (
"Size of template specialization: " , stringify ! (
diff --git a/tests/expectations/tests/crtp.rs b/tests/expectations/tests/crtp.rs
index 03fef4cd..f76f78f8 100644
--- a/tests/expectations/tests/crtp.rs
+++ b/tests/expectations/tests/crtp.rs
@@ -51,7 +51,7 @@ impl Default for DerivedFromBaseWithDestructor {
fn default() -> Self { unsafe { ::std::mem::zeroed() } }
}
#[test]
-fn __bindgen_test_layout_Base_instantiation_1() {
+fn __bindgen_test_layout_Base_instantiation() {
assert_eq!(::std::mem::size_of::<Base>() , 1usize , concat ! (
"Size of template specialization: " , stringify ! ( Base ) ));
assert_eq!(::std::mem::align_of::<Base>() , 1usize , concat ! (
@@ -59,7 +59,7 @@ fn __bindgen_test_layout_Base_instantiation_1() {
));
}
#[test]
-fn __bindgen_test_layout_BaseWithDestructor_instantiation_2() {
+fn __bindgen_test_layout_BaseWithDestructor_instantiation() {
assert_eq!(::std::mem::size_of::<BaseWithDestructor>() , 1usize , concat !
(
"Size of template specialization: " , stringify ! (
diff --git a/tests/expectations/tests/default-template-parameter.rs b/tests/expectations/tests/default-template-parameter.rs
index 5781c7fb..e57761ce 100644
--- a/tests/expectations/tests/default-template-parameter.rs
+++ b/tests/expectations/tests/default-template-parameter.rs
@@ -16,7 +16,7 @@ impl <T, U> Default for Foo<T, U> {
fn default() -> Self { unsafe { ::std::mem::zeroed() } }
}
#[test]
-fn __bindgen_test_layout_Foo_instantiation_1() {
+fn __bindgen_test_layout_Foo_instantiation() {
assert_eq!(::std::mem::size_of::<Foo<bool, ::std::os::raw::c_int>>() ,
8usize , concat ! (
"Size of template specialization: " , stringify ! (
diff --git a/tests/expectations/tests/enum_and_vtable_mangling.rs b/tests/expectations/tests/enum_and_vtable_mangling.rs
index 2b58a6b2..9cdd1127 100644
--- a/tests/expectations/tests/enum_and_vtable_mangling.rs
+++ b/tests/expectations/tests/enum_and_vtable_mangling.rs
@@ -34,3 +34,7 @@ impl Clone for C {
impl Default for C {
fn default() -> Self { unsafe { ::std::mem::zeroed() } }
}
+extern "C" {
+ #[link_name = "_ZN1C5matchEv"]
+ pub fn C_match(this: *mut ::std::os::raw::c_void);
+}
diff --git a/tests/expectations/tests/forward-declaration-autoptr.rs b/tests/expectations/tests/forward-declaration-autoptr.rs
index 3d2708d5..df519fe9 100644
--- a/tests/expectations/tests/forward-declaration-autoptr.rs
+++ b/tests/expectations/tests/forward-declaration-autoptr.rs
@@ -41,3 +41,12 @@ impl Clone for Bar {
impl Default for Bar {
fn default() -> Self { unsafe { ::std::mem::zeroed() } }
}
+#[test]
+fn __bindgen_test_layout_RefPtr_instantiation() {
+ assert_eq!(::std::mem::size_of::<RefPtr<Foo>>() , 8usize , concat ! (
+ "Size of template specialization: " , stringify ! ( RefPtr<Foo>
+ ) ));
+ assert_eq!(::std::mem::align_of::<RefPtr<Foo>>() , 8usize , concat ! (
+ "Alignment of template specialization: " , stringify ! (
+ RefPtr<Foo> ) ));
+}
diff --git a/tests/expectations/tests/gen-constructors-neg.rs b/tests/expectations/tests/gen-constructors-neg.rs
index c894b95c..834d5f2e 100644
--- a/tests/expectations/tests/gen-constructors-neg.rs
+++ b/tests/expectations/tests/gen-constructors-neg.rs
@@ -19,3 +19,7 @@ fn bindgen_test_layout_Foo() {
impl Clone for Foo {
fn clone(&self) -> Self { *self }
}
+extern "C" {
+ #[link_name = "_ZN3FooC1Ei"]
+ pub fn Foo_Foo(this: *mut Foo, a: ::std::os::raw::c_int);
+}
diff --git a/tests/expectations/tests/gen-destructors-neg.rs b/tests/expectations/tests/gen-destructors-neg.rs
index 64373d75..c7c97104 100644
--- a/tests/expectations/tests/gen-destructors-neg.rs
+++ b/tests/expectations/tests/gen-destructors-neg.rs
@@ -21,3 +21,7 @@ fn bindgen_test_layout_Foo() {
"Alignment of field: " , stringify ! ( Foo ) , "::" ,
stringify ! ( bar ) ));
}
+extern "C" {
+ #[link_name = "_ZN3FooD1Ev"]
+ pub fn Foo_Foo_destructor(this: *mut Foo);
+}
diff --git a/tests/expectations/tests/inner_template_self.rs b/tests/expectations/tests/inner_template_self.rs
index e1a5302f..26b35d8a 100644
--- a/tests/expectations/tests/inner_template_self.rs
+++ b/tests/expectations/tests/inner_template_self.rs
@@ -36,3 +36,12 @@ impl Clone for InstantiateIt {
impl Default for InstantiateIt {
fn default() -> Self { unsafe { ::std::mem::zeroed() } }
}
+#[test]
+fn __bindgen_test_layout_LinkedList_instantiation() {
+ assert_eq!(::std::mem::size_of::<LinkedList>() , 16usize , concat ! (
+ "Size of template specialization: " , stringify ! ( LinkedList
+ ) ));
+ assert_eq!(::std::mem::align_of::<LinkedList>() , 8usize , concat ! (
+ "Alignment of template specialization: " , stringify ! (
+ LinkedList ) ));
+}
diff --git a/tests/expectations/tests/issue-372.rs b/tests/expectations/tests/issue-372.rs
index 8a115924..687ae25f 100644
--- a/tests/expectations/tests/issue-372.rs
+++ b/tests/expectations/tests/issue-372.rs
@@ -101,4 +101,15 @@ pub mod root {
impl Default for F {
fn default() -> Self { unsafe { ::std::mem::zeroed() } }
}
+ #[test]
+ fn __bindgen_test_layout_C_instantiation() {
+ assert_eq!(::std::mem::size_of::<[u64; 33usize]>() , 264usize , concat
+ ! (
+ "Size of template specialization: " , stringify ! (
+ [u64; 33usize] ) ));
+ assert_eq!(::std::mem::align_of::<[u64; 33usize]>() , 8usize , concat
+ ! (
+ "Alignment of template specialization: " , stringify ! (
+ [u64; 33usize] ) ));
+ }
}
diff --git a/tests/expectations/tests/issue-569-non-type-template-params-causing-layout-test-failures.rs b/tests/expectations/tests/issue-569-non-type-template-params-causing-layout-test-failures.rs
index 11d60e04..1a783f7d 100644
--- a/tests/expectations/tests/issue-569-non-type-template-params-causing-layout-test-failures.rs
+++ b/tests/expectations/tests/issue-569-non-type-template-params-causing-layout-test-failures.rs
@@ -32,7 +32,7 @@ impl Default for JS_AutoIdVector {
fn default() -> Self { unsafe { ::std::mem::zeroed() } }
}
#[test]
-fn __bindgen_test_layout_JS_Base_instantiation_2() {
+fn __bindgen_test_layout_JS_Base_instantiation() {
assert_eq!(::std::mem::size_of::<JS_Base>() , 1usize , concat ! (
"Size of template specialization: " , stringify ! ( JS_Base )
));
diff --git a/tests/expectations/tests/issue-573-layout-test-failures.rs b/tests/expectations/tests/issue-573-layout-test-failures.rs
index f82b902d..7d87aabe 100644
--- a/tests/expectations/tests/issue-573-layout-test-failures.rs
+++ b/tests/expectations/tests/issue-573-layout-test-failures.rs
@@ -28,3 +28,11 @@ fn bindgen_test_layout_AutoIdVector() {
impl Default for AutoIdVector {
fn default() -> Self { unsafe { ::std::mem::zeroed() } }
}
+#[test]
+fn __bindgen_test_layout_Outer_instantiation() {
+ assert_eq!(::std::mem::size_of::<Outer>() , 1usize , concat ! (
+ "Size of template specialization: " , stringify ! ( Outer ) ));
+ assert_eq!(::std::mem::align_of::<Outer>() , 1usize , concat ! (
+ "Alignment of template specialization: " , stringify ! ( Outer
+ ) ));
+}
diff --git a/tests/expectations/tests/issue-574-assertion-failure-in-codegen.rs b/tests/expectations/tests/issue-574-assertion-failure-in-codegen.rs
index 610c0c83..a895434d 100644
--- a/tests/expectations/tests/issue-574-assertion-failure-in-codegen.rs
+++ b/tests/expectations/tests/issue-574-assertion-failure-in-codegen.rs
@@ -36,3 +36,11 @@ extern "C" {
#[link_name = "AutoIdVector"]
pub static mut AutoIdVector: _bindgen_ty_1;
}
+#[test]
+fn __bindgen_test_layout_a_instantiation() {
+ assert_eq!(::std::mem::size_of::<a>() , 1usize , concat ! (
+ "Size of template specialization: " , stringify ! ( a ) ));
+ assert_eq!(::std::mem::align_of::<a>() , 1usize , concat ! (
+ "Alignment of template specialization: " , stringify ! ( a )
+ ));
+}
diff --git a/tests/expectations/tests/issue-584-stylo-template-analysis-panic.rs b/tests/expectations/tests/issue-584-stylo-template-analysis-panic.rs
index b7fa68a3..c0933df3 100644
--- a/tests/expectations/tests/issue-584-stylo-template-analysis-panic.rs
+++ b/tests/expectations/tests/issue-584-stylo-template-analysis-panic.rs
@@ -79,3 +79,11 @@ extern "C" {
#[link_name = "_Z25Servo_Element_GetSnapshotv"]
pub fn Servo_Element_GetSnapshot() -> A;
}
+#[test]
+fn __bindgen_test_layout_f_instantiation() {
+ assert_eq!(::std::mem::size_of::<f>() , 1usize , concat ! (
+ "Size of template specialization: " , stringify ! ( f ) ));
+ assert_eq!(::std::mem::align_of::<f>() , 1usize , concat ! (
+ "Alignment of template specialization: " , stringify ! ( f )
+ ));
+}
diff --git a/tests/expectations/tests/issue-674-1.rs b/tests/expectations/tests/issue-674-1.rs
index 01257c23..e8b81dd3 100644
--- a/tests/expectations/tests/issue-674-1.rs
+++ b/tests/expectations/tests/issue-674-1.rs
@@ -43,4 +43,13 @@ pub mod root {
impl Clone for CapturingContentInfo {
fn clone(&self) -> Self { *self }
}
+ #[test]
+ fn __bindgen_test_layout_Maybe_instantiation() {
+ assert_eq!(::std::mem::size_of::<u8>() , 1usize , concat ! (
+ "Size of template specialization: " , stringify ! ( u8 )
+ ));
+ assert_eq!(::std::mem::align_of::<u8>() , 1usize , concat ! (
+ "Alignment of template specialization: " , stringify ! ( u8
+ ) ));
+ }
}
diff --git a/tests/expectations/tests/issue-674-2.rs b/tests/expectations/tests/issue-674-2.rs
index 819eff05..d7b0bb1c 100644
--- a/tests/expectations/tests/issue-674-2.rs
+++ b/tests/expectations/tests/issue-674-2.rs
@@ -66,4 +66,24 @@ pub mod root {
pub struct StaticRefPtr {
pub _address: u8,
}
+ #[test]
+ fn __bindgen_test_layout_Rooted_instantiation() {
+ assert_eq!(::std::mem::size_of::<u8>() , 1usize , concat ! (
+ "Size of template specialization: " , stringify ! ( u8 )
+ ));
+ assert_eq!(::std::mem::align_of::<u8>() , 1usize , concat ! (
+ "Alignment of template specialization: " , stringify ! ( u8
+ ) ));
+ }
+ #[test]
+ fn __bindgen_test_layout_StaticRefPtr_instantiation() {
+ assert_eq!(::std::mem::size_of::<root::StaticRefPtr>() , 1usize ,
+ concat ! (
+ "Size of template specialization: " , stringify ! (
+ root::StaticRefPtr ) ));
+ assert_eq!(::std::mem::align_of::<root::StaticRefPtr>() , 1usize ,
+ concat ! (
+ "Alignment of template specialization: " , stringify ! (
+ root::StaticRefPtr ) ));
+ }
}
diff --git a/tests/expectations/tests/issue-674-3.rs b/tests/expectations/tests/issue-674-3.rs
index 6e915a18..8fd06b76 100644
--- a/tests/expectations/tests/issue-674-3.rs
+++ b/tests/expectations/tests/issue-674-3.rs
@@ -57,4 +57,13 @@ pub mod root {
impl Clone for nsCSSValue {
fn clone(&self) -> Self { *self }
}
+ #[test]
+ fn __bindgen_test_layout_nsRefPtrHashtable_instantiation() {
+ assert_eq!(::std::mem::size_of::<u8>() , 1usize , concat ! (
+ "Size of template specialization: " , stringify ! ( u8 )
+ ));
+ assert_eq!(::std::mem::align_of::<u8>() , 1usize , concat ! (
+ "Alignment of template specialization: " , stringify ! ( u8
+ ) ));
+ }
}
diff --git a/tests/expectations/tests/issue-691-template-parameter-virtual.rs b/tests/expectations/tests/issue-691-template-parameter-virtual.rs
index b0bcb541..de43c036 100644
--- a/tests/expectations/tests/issue-691-template-parameter-virtual.rs
+++ b/tests/expectations/tests/issue-691-template-parameter-virtual.rs
@@ -51,7 +51,7 @@ impl Default for ServoElementSnapshotTable {
fn default() -> Self { unsafe { ::std::mem::zeroed() } }
}
#[test]
-fn __bindgen_test_layout_Set_instantiation_1() {
+fn __bindgen_test_layout_Set_instantiation() {
assert_eq!(::std::mem::size_of::<Set>() , 4usize , concat ! (
"Size of template specialization: " , stringify ! ( Set ) ));
assert_eq!(::std::mem::align_of::<Set>() , 4usize , concat ! (
diff --git a/tests/expectations/tests/issue-739-pointer-wide-bitfield.rs b/tests/expectations/tests/issue-739-pointer-wide-bitfield.rs
new file mode 100644
index 00000000..17e63981
--- /dev/null
+++ b/tests/expectations/tests/issue-739-pointer-wide-bitfield.rs
@@ -0,0 +1,22 @@
+/* automatically generated by rust-bindgen */
+
+
+#![allow(dead_code, non_snake_case, non_camel_case_types, non_upper_case_globals)]
+
+
+#[repr(C)]
+#[derive(Debug, Default, Copy)]
+pub struct Foo {
+ pub _bitfield_1: [u64; 4usize],
+ pub __bindgen_align: [u64; 0usize],
+}
+#[test]
+fn bindgen_test_layout_Foo() {
+ assert_eq!(::std::mem::size_of::<Foo>() , 32usize , concat ! (
+ "Size of: " , stringify ! ( Foo ) ));
+ assert_eq! (::std::mem::align_of::<Foo>() , 8usize , concat ! (
+ "Alignment of " , stringify ! ( Foo ) ));
+}
+impl Clone for Foo {
+ fn clone(&self) -> Self { *self }
+}
diff --git a/tests/expectations/tests/jsval_layout_opaque.rs b/tests/expectations/tests/jsval_layout_opaque.rs
index 4010b0d8..980adbcf 100644
--- a/tests/expectations/tests/jsval_layout_opaque.rs
+++ b/tests/expectations/tests/jsval_layout_opaque.rs
@@ -132,49 +132,85 @@ impl Default for jsval_layout__bindgen_ty_1 {
impl jsval_layout__bindgen_ty_1 {
#[inline]
pub fn payload47(&self) -> u64 {
- let mask = 140737488355327usize as u64;
- let unit_field_val: u64 =
- unsafe { ::std::mem::transmute(self._bitfield_1) };
+ let mut unit_field_val: u64 = unsafe { ::std::mem::uninitialized() };
+ unsafe {
+ ::std::ptr::copy_nonoverlapping(&self._bitfield_1 as *const _ as
+ *const u8,
+ &mut unit_field_val as *mut u64 as
+ *mut u8,
+ ::std::mem::size_of::<u64>())
+ };
+ let mask = 140737488355327u64 as u64;
let val = (unit_field_val & mask) >> 0usize;
unsafe { ::std::mem::transmute(val as u64) }
}
#[inline]
pub fn set_payload47(&mut self, val: u64) {
- let mask = 140737488355327usize as u64;
+ let mask = 140737488355327u64 as u64;
let val = val as u64 as u64;
- let mut unit_field_val: u64 =
- unsafe { ::std::mem::transmute(self._bitfield_1) };
+ let mut unit_field_val: u64 = unsafe { ::std::mem::uninitialized() };
+ unsafe {
+ ::std::ptr::copy_nonoverlapping(&self._bitfield_1 as *const _ as
+ *const u8,
+ &mut unit_field_val as *mut u64 as
+ *mut u8,
+ ::std::mem::size_of::<u64>())
+ };
unit_field_val &= !mask;
unit_field_val |= (val << 0usize) & mask;
- self._bitfield_1 = unsafe { ::std::mem::transmute(unit_field_val) };
+ unsafe {
+ ::std::ptr::copy_nonoverlapping(&unit_field_val as *const _ as
+ *const u8,
+ &mut self._bitfield_1 as *mut _ as
+ *mut u8,
+ ::std::mem::size_of::<u64>());
+ }
}
#[inline]
pub fn tag(&self) -> JSValueTag {
- let mask = 18446603336221196288usize as u64;
- let unit_field_val: u64 =
- unsafe { ::std::mem::transmute(self._bitfield_1) };
+ let mut unit_field_val: u64 = unsafe { ::std::mem::uninitialized() };
+ unsafe {
+ ::std::ptr::copy_nonoverlapping(&self._bitfield_1 as *const _ as
+ *const u8,
+ &mut unit_field_val as *mut u64 as
+ *mut u8,
+ ::std::mem::size_of::<u64>())
+ };
+ let mask = 18446603336221196288u64 as u64;
let val = (unit_field_val & mask) >> 47usize;
unsafe { ::std::mem::transmute(val as u32) }
}
#[inline]
pub fn set_tag(&mut self, val: JSValueTag) {
- let mask = 18446603336221196288usize as u64;
+ let mask = 18446603336221196288u64 as u64;
let val = val as u32 as u64;
- let mut unit_field_val: u64 =
- unsafe { ::std::mem::transmute(self._bitfield_1) };
+ let mut unit_field_val: u64 = unsafe { ::std::mem::uninitialized() };
+ unsafe {
+ ::std::ptr::copy_nonoverlapping(&self._bitfield_1 as *const _ as
+ *const u8,
+ &mut unit_field_val as *mut u64 as
+ *mut u8,
+ ::std::mem::size_of::<u64>())
+ };
unit_field_val &= !mask;
unit_field_val |= (val << 47usize) & mask;
- self._bitfield_1 = unsafe { ::std::mem::transmute(unit_field_val) };
+ unsafe {
+ ::std::ptr::copy_nonoverlapping(&unit_field_val as *const _ as
+ *const u8,
+ &mut self._bitfield_1 as *mut _ as
+ *mut u8,
+ ::std::mem::size_of::<u64>());
+ }
}
#[inline]
pub fn new_bitfield_1(payload47: u64, tag: JSValueTag) -> u64 {
({
({ 0 } |
((payload47 as u64 as u64) << 0usize) &
- (140737488355327usize as u64))
+ (140737488355327u64 as u64))
} |
((tag as u32 as u64) << 47usize) &
- (18446603336221196288usize as u64))
+ (18446603336221196288u64 as u64))
}
}
#[repr(C)]
diff --git a/tests/expectations/tests/layout_align.rs b/tests/expectations/tests/layout_align.rs
index efcb9753..a8f981e8 100644
--- a/tests/expectations/tests/layout_align.rs
+++ b/tests/expectations/tests/layout_align.rs
@@ -92,57 +92,111 @@ impl Clone for rte_eth_link {
impl rte_eth_link {
#[inline]
pub fn link_duplex(&self) -> u16 {
- let mask = 1usize as u8;
- let unit_field_val: u8 =
- unsafe { ::std::mem::transmute(self._bitfield_1) };
+ let mut unit_field_val: u8 = unsafe { ::std::mem::uninitialized() };
+ unsafe {
+ ::std::ptr::copy_nonoverlapping(&self._bitfield_1 as *const _ as
+ *const u8,
+ &mut unit_field_val as *mut u8 as
+ *mut u8,
+ ::std::mem::size_of::<u8>())
+ };
+ let mask = 1u64 as u8;
let val = (unit_field_val & mask) >> 0usize;
unsafe { ::std::mem::transmute(val as u16) }
}
#[inline]
pub fn set_link_duplex(&mut self, val: u16) {
- let mask = 1usize as u8;
+ let mask = 1u64 as u8;
let val = val as u16 as u8;
- let mut unit_field_val: u8 =
- unsafe { ::std::mem::transmute(self._bitfield_1) };
+ let mut unit_field_val: u8 = unsafe { ::std::mem::uninitialized() };
+ unsafe {
+ ::std::ptr::copy_nonoverlapping(&self._bitfield_1 as *const _ as
+ *const u8,
+ &mut unit_field_val as *mut u8 as
+ *mut u8,
+ ::std::mem::size_of::<u8>())
+ };
unit_field_val &= !mask;
unit_field_val |= (val << 0usize) & mask;
- self._bitfield_1 = unsafe { ::std::mem::transmute(unit_field_val) };
+ unsafe {
+ ::std::ptr::copy_nonoverlapping(&unit_field_val as *const _ as
+ *const u8,
+ &mut self._bitfield_1 as *mut _ as
+ *mut u8,
+ ::std::mem::size_of::<u8>());
+ }
}
#[inline]
pub fn link_autoneg(&self) -> u16 {
- let mask = 2usize as u8;
- let unit_field_val: u8 =
- unsafe { ::std::mem::transmute(self._bitfield_1) };
+ let mut unit_field_val: u8 = unsafe { ::std::mem::uninitialized() };
+ unsafe {
+ ::std::ptr::copy_nonoverlapping(&self._bitfield_1 as *const _ as
+ *const u8,
+ &mut unit_field_val as *mut u8 as
+ *mut u8,
+ ::std::mem::size_of::<u8>())
+ };
+ let mask = 2u64 as u8;
let val = (unit_field_val & mask) >> 1usize;
unsafe { ::std::mem::transmute(val as u16) }
}
#[inline]
pub fn set_link_autoneg(&mut self, val: u16) {
- let mask = 2usize as u8;
+ let mask = 2u64 as u8;
let val = val as u16 as u8;
- let mut unit_field_val: u8 =
- unsafe { ::std::mem::transmute(self._bitfield_1) };
+ let mut unit_field_val: u8 = unsafe { ::std::mem::uninitialized() };
+ unsafe {
+ ::std::ptr::copy_nonoverlapping(&self._bitfield_1 as *const _ as
+ *const u8,
+ &mut unit_field_val as *mut u8 as
+ *mut u8,
+ ::std::mem::size_of::<u8>())
+ };
unit_field_val &= !mask;
unit_field_val |= (val << 1usize) & mask;
- self._bitfield_1 = unsafe { ::std::mem::transmute(unit_field_val) };
+ unsafe {
+ ::std::ptr::copy_nonoverlapping(&unit_field_val as *const _ as
+ *const u8,
+ &mut self._bitfield_1 as *mut _ as
+ *mut u8,
+ ::std::mem::size_of::<u8>());
+ }
}
#[inline]
pub fn link_status(&self) -> u16 {
- let mask = 4usize as u8;
- let unit_field_val: u8 =
- unsafe { ::std::mem::transmute(self._bitfield_1) };
+ let mut unit_field_val: u8 = unsafe { ::std::mem::uninitialized() };
+ unsafe {
+ ::std::ptr::copy_nonoverlapping(&self._bitfield_1 as *const _ as
+ *const u8,
+ &mut unit_field_val as *mut u8 as
+ *mut u8,
+ ::std::mem::size_of::<u8>())
+ };
+ let mask = 4u64 as u8;
let val = (unit_field_val & mask) >> 2usize;
unsafe { ::std::mem::transmute(val as u16) }
}
#[inline]
pub fn set_link_status(&mut self, val: u16) {
- let mask = 4usize as u8;
+ let mask = 4u64 as u8;
let val = val as u16 as u8;
- let mut unit_field_val: u8 =
- unsafe { ::std::mem::transmute(self._bitfield_1) };
+ let mut unit_field_val: u8 = unsafe { ::std::mem::uninitialized() };
+ unsafe {
+ ::std::ptr::copy_nonoverlapping(&self._bitfield_1 as *const _ as
+ *const u8,
+ &mut unit_field_val as *mut u8 as
+ *mut u8,
+ ::std::mem::size_of::<u8>())
+ };
unit_field_val &= !mask;
unit_field_val |= (val << 2usize) & mask;
- self._bitfield_1 = unsafe { ::std::mem::transmute(unit_field_val) };
+ unsafe {
+ ::std::ptr::copy_nonoverlapping(&unit_field_val as *const _ as
+ *const u8,
+ &mut self._bitfield_1 as *mut _ as
+ *mut u8,
+ ::std::mem::size_of::<u8>());
+ }
}
#[inline]
pub fn new_bitfield_1(link_duplex: u16, link_autoneg: u16,
@@ -150,9 +204,8 @@ impl rte_eth_link {
({
({
({ 0 } |
- ((link_duplex as u16 as u8) << 0usize) &
- (1usize as u8))
- } | ((link_autoneg as u16 as u8) << 1usize) & (2usize as u8))
- } | ((link_status as u16 as u8) << 2usize) & (4usize as u8))
+ ((link_duplex as u16 as u8) << 0usize) & (1u64 as u8))
+ } | ((link_autoneg as u16 as u8) << 1usize) & (2u64 as u8))
+ } | ((link_status as u16 as u8) << 2usize) & (4u64 as u8))
}
}
diff --git a/tests/expectations/tests/layout_eth_conf.rs b/tests/expectations/tests/layout_eth_conf.rs
index 17ce893b..d35f8d81 100644
--- a/tests/expectations/tests/layout_eth_conf.rs
+++ b/tests/expectations/tests/layout_eth_conf.rs
@@ -121,165 +121,327 @@ impl Default for rte_eth_rxmode {
impl rte_eth_rxmode {
#[inline]
pub fn header_split(&self) -> u16 {
- let mask = 1usize as u16;
- let unit_field_val: u16 =
- unsafe { ::std::mem::transmute(self._bitfield_1) };
+ let mut unit_field_val: u16 = unsafe { ::std::mem::uninitialized() };
+ unsafe {
+ ::std::ptr::copy_nonoverlapping(&self._bitfield_1 as *const _ as
+ *const u8,
+ &mut unit_field_val as *mut u16 as
+ *mut u8,
+ ::std::mem::size_of::<u16>())
+ };
+ let mask = 1u64 as u16;
let val = (unit_field_val & mask) >> 0usize;
unsafe { ::std::mem::transmute(val as u16) }
}
#[inline]
pub fn set_header_split(&mut self, val: u16) {
- let mask = 1usize as u16;
+ let mask = 1u64 as u16;
let val = val as u16 as u16;
- let mut unit_field_val: u16 =
- unsafe { ::std::mem::transmute(self._bitfield_1) };
+ let mut unit_field_val: u16 = unsafe { ::std::mem::uninitialized() };
+ unsafe {
+ ::std::ptr::copy_nonoverlapping(&self._bitfield_1 as *const _ as
+ *const u8,
+ &mut unit_field_val as *mut u16 as
+ *mut u8,
+ ::std::mem::size_of::<u16>())
+ };
unit_field_val &= !mask;
unit_field_val |= (val << 0usize) & mask;
- self._bitfield_1 = unsafe { ::std::mem::transmute(unit_field_val) };
+ unsafe {
+ ::std::ptr::copy_nonoverlapping(&unit_field_val as *const _ as
+ *const u8,
+ &mut self._bitfield_1 as *mut _ as
+ *mut u8,
+ ::std::mem::size_of::<u16>());
+ }
}
#[inline]
pub fn hw_ip_checksum(&self) -> u16 {
- let mask = 2usize as u16;
- let unit_field_val: u16 =
- unsafe { ::std::mem::transmute(self._bitfield_1) };
+ let mut unit_field_val: u16 = unsafe { ::std::mem::uninitialized() };
+ unsafe {
+ ::std::ptr::copy_nonoverlapping(&self._bitfield_1 as *const _ as
+ *const u8,
+ &mut unit_field_val as *mut u16 as
+ *mut u8,
+ ::std::mem::size_of::<u16>())
+ };
+ let mask = 2u64 as u16;
let val = (unit_field_val & mask) >> 1usize;
unsafe { ::std::mem::transmute(val as u16) }
}
#[inline]
pub fn set_hw_ip_checksum(&mut self, val: u16) {
- let mask = 2usize as u16;
+ let mask = 2u64 as u16;
let val = val as u16 as u16;
- let mut unit_field_val: u16 =
- unsafe { ::std::mem::transmute(self._bitfield_1) };
+ let mut unit_field_val: u16 = unsafe { ::std::mem::uninitialized() };
+ unsafe {
+ ::std::ptr::copy_nonoverlapping(&self._bitfield_1 as *const _ as
+ *const u8,
+ &mut unit_field_val as *mut u16 as
+ *mut u8,
+ ::std::mem::size_of::<u16>())
+ };
unit_field_val &= !mask;
unit_field_val |= (val << 1usize) & mask;
- self._bitfield_1 = unsafe { ::std::mem::transmute(unit_field_val) };
+ unsafe {
+ ::std::ptr::copy_nonoverlapping(&unit_field_val as *const _ as
+ *const u8,
+ &mut self._bitfield_1 as *mut _ as
+ *mut u8,
+ ::std::mem::size_of::<u16>());
+ }
}
#[inline]
pub fn hw_vlan_filter(&self) -> u16 {
- let mask = 4usize as u16;
- let unit_field_val: u16 =
- unsafe { ::std::mem::transmute(self._bitfield_1) };
+ let mut unit_field_val: u16 = unsafe { ::std::mem::uninitialized() };
+ unsafe {
+ ::std::ptr::copy_nonoverlapping(&self._bitfield_1 as *const _ as
+ *const u8,
+ &mut unit_field_val as *mut u16 as
+ *mut u8,
+ ::std::mem::size_of::<u16>())
+ };
+ let mask = 4u64 as u16;
let val = (unit_field_val & mask) >> 2usize;
unsafe { ::std::mem::transmute(val as u16) }
}
#[inline]
pub fn set_hw_vlan_filter(&mut self, val: u16) {
- let mask = 4usize as u16;
+ let mask = 4u64 as u16;
let val = val as u16 as u16;
- let mut unit_field_val: u16 =
- unsafe { ::std::mem::transmute(self._bitfield_1) };
+ let mut unit_field_val: u16 = unsafe { ::std::mem::uninitialized() };
+ unsafe {
+ ::std::ptr::copy_nonoverlapping(&self._bitfield_1 as *const _ as
+ *const u8,
+ &mut unit_field_val as *mut u16 as
+ *mut u8,
+ ::std::mem::size_of::<u16>())
+ };
unit_field_val &= !mask;
unit_field_val |= (val << 2usize) & mask;
- self._bitfield_1 = unsafe { ::std::mem::transmute(unit_field_val) };
+ unsafe {
+ ::std::ptr::copy_nonoverlapping(&unit_field_val as *const _ as
+ *const u8,
+ &mut self._bitfield_1 as *mut _ as
+ *mut u8,
+ ::std::mem::size_of::<u16>());
+ }
}
#[inline]
pub fn hw_vlan_strip(&self) -> u16 {
- let mask = 8usize as u16;
- let unit_field_val: u16 =
- unsafe { ::std::mem::transmute(self._bitfield_1) };
+ let mut unit_field_val: u16 = unsafe { ::std::mem::uninitialized() };
+ unsafe {
+ ::std::ptr::copy_nonoverlapping(&self._bitfield_1 as *const _ as
+ *const u8,
+ &mut unit_field_val as *mut u16 as
+ *mut u8,
+ ::std::mem::size_of::<u16>())
+ };
+ let mask = 8u64 as u16;
let val = (unit_field_val & mask) >> 3usize;
unsafe { ::std::mem::transmute(val as u16) }
}
#[inline]
pub fn set_hw_vlan_strip(&mut self, val: u16) {
- let mask = 8usize as u16;
+ let mask = 8u64 as u16;
let val = val as u16 as u16;
- let mut unit_field_val: u16 =
- unsafe { ::std::mem::transmute(self._bitfield_1) };
+ let mut unit_field_val: u16 = unsafe { ::std::mem::uninitialized() };
+ unsafe {
+ ::std::ptr::copy_nonoverlapping(&self._bitfield_1 as *const _ as
+ *const u8,
+ &mut unit_field_val as *mut u16 as
+ *mut u8,
+ ::std::mem::size_of::<u16>())
+ };
unit_field_val &= !mask;
unit_field_val |= (val << 3usize) & mask;
- self._bitfield_1 = unsafe { ::std::mem::transmute(unit_field_val) };
+ unsafe {
+ ::std::ptr::copy_nonoverlapping(&unit_field_val as *const _ as
+ *const u8,
+ &mut self._bitfield_1 as *mut _ as
+ *mut u8,
+ ::std::mem::size_of::<u16>());
+ }
}
#[inline]
pub fn hw_vlan_extend(&self) -> u16 {
- let mask = 16usize as u16;
- let unit_field_val: u16 =
- unsafe { ::std::mem::transmute(self._bitfield_1) };
+ let mut unit_field_val: u16 = unsafe { ::std::mem::uninitialized() };
+ unsafe {
+ ::std::ptr::copy_nonoverlapping(&self._bitfield_1 as *const _ as
+ *const u8,
+ &mut unit_field_val as *mut u16 as
+ *mut u8,
+ ::std::mem::size_of::<u16>())
+ };
+ let mask = 16u64 as u16;
let val = (unit_field_val & mask) >> 4usize;
unsafe { ::std::mem::transmute(val as u16) }
}
#[inline]
pub fn set_hw_vlan_extend(&mut self, val: u16) {
- let mask = 16usize as u16;
+ let mask = 16u64 as u16;
let val = val as u16 as u16;
- let mut unit_field_val: u16 =
- unsafe { ::std::mem::transmute(self._bitfield_1) };
+ let mut unit_field_val: u16 = unsafe { ::std::mem::uninitialized() };
+ unsafe {
+ ::std::ptr::copy_nonoverlapping(&self._bitfield_1 as *const _ as
+ *const u8,
+ &mut unit_field_val as *mut u16 as
+ *mut u8,
+ ::std::mem::size_of::<u16>())
+ };
unit_field_val &= !mask;
unit_field_val |= (val << 4usize) & mask;
- self._bitfield_1 = unsafe { ::std::mem::transmute(unit_field_val) };
+ unsafe {
+ ::std::ptr::copy_nonoverlapping(&unit_field_val as *const _ as
+ *const u8,
+ &mut self._bitfield_1 as *mut _ as
+ *mut u8,
+ ::std::mem::size_of::<u16>());
+ }
}
#[inline]
pub fn jumbo_frame(&self) -> u16 {
- let mask = 32usize as u16;
- let unit_field_val: u16 =
- unsafe { ::std::mem::transmute(self._bitfield_1) };
+ let mut unit_field_val: u16 = unsafe { ::std::mem::uninitialized() };
+ unsafe {
+ ::std::ptr::copy_nonoverlapping(&self._bitfield_1 as *const _ as
+ *const u8,
+ &mut unit_field_val as *mut u16 as
+ *mut u8,
+ ::std::mem::size_of::<u16>())
+ };
+ let mask = 32u64 as u16;
let val = (unit_field_val & mask) >> 5usize;
unsafe { ::std::mem::transmute(val as u16) }
}
#[inline]
pub fn set_jumbo_frame(&mut self, val: u16) {
- let mask = 32usize as u16;
+ let mask = 32u64 as u16;
let val = val as u16 as u16;
- let mut unit_field_val: u16 =
- unsafe { ::std::mem::transmute(self._bitfield_1) };
+ let mut unit_field_val: u16 = unsafe { ::std::mem::uninitialized() };
+ unsafe {
+ ::std::ptr::copy_nonoverlapping(&self._bitfield_1 as *const _ as
+ *const u8,
+ &mut unit_field_val as *mut u16 as
+ *mut u8,
+ ::std::mem::size_of::<u16>())
+ };
unit_field_val &= !mask;
unit_field_val |= (val << 5usize) & mask;
- self._bitfield_1 = unsafe { ::std::mem::transmute(unit_field_val) };
+ unsafe {
+ ::std::ptr::copy_nonoverlapping(&unit_field_val as *const _ as
+ *const u8,
+ &mut self._bitfield_1 as *mut _ as
+ *mut u8,
+ ::std::mem::size_of::<u16>());
+ }
}
#[inline]
pub fn hw_strip_crc(&self) -> u16 {
- let mask = 64usize as u16;
- let unit_field_val: u16 =
- unsafe { ::std::mem::transmute(self._bitfield_1) };
+ let mut unit_field_val: u16 = unsafe { ::std::mem::uninitialized() };
+ unsafe {
+ ::std::ptr::copy_nonoverlapping(&self._bitfield_1 as *const _ as
+ *const u8,
+ &mut unit_field_val as *mut u16 as
+ *mut u8,
+ ::std::mem::size_of::<u16>())
+ };
+ let mask = 64u64 as u16;
let val = (unit_field_val & mask) >> 6usize;
unsafe { ::std::mem::transmute(val as u16) }
}
#[inline]
pub fn set_hw_strip_crc(&mut self, val: u16) {
- let mask = 64usize as u16;
+ let mask = 64u64 as u16;
let val = val as u16 as u16;
- let mut unit_field_val: u16 =
- unsafe { ::std::mem::transmute(self._bitfield_1) };
+ let mut unit_field_val: u16 = unsafe { ::std::mem::uninitialized() };
+ unsafe {
+ ::std::ptr::copy_nonoverlapping(&self._bitfield_1 as *const _ as
+ *const u8,
+ &mut unit_field_val as *mut u16 as
+ *mut u8,
+ ::std::mem::size_of::<u16>())
+ };
unit_field_val &= !mask;
unit_field_val |= (val << 6usize) & mask;
- self._bitfield_1 = unsafe { ::std::mem::transmute(unit_field_val) };
+ unsafe {
+ ::std::ptr::copy_nonoverlapping(&unit_field_val as *const _ as
+ *const u8,
+ &mut self._bitfield_1 as *mut _ as
+ *mut u8,
+ ::std::mem::size_of::<u16>());
+ }
}
#[inline]
pub fn enable_scatter(&self) -> u16 {
- let mask = 128usize as u16;
- let unit_field_val: u16 =
- unsafe { ::std::mem::transmute(self._bitfield_1) };
+ let mut unit_field_val: u16 = unsafe { ::std::mem::uninitialized() };
+ unsafe {
+ ::std::ptr::copy_nonoverlapping(&self._bitfield_1 as *const _ as
+ *const u8,
+ &mut unit_field_val as *mut u16 as
+ *mut u8,
+ ::std::mem::size_of::<u16>())
+ };
+ let mask = 128u64 as u16;
let val = (unit_field_val & mask) >> 7usize;
unsafe { ::std::mem::transmute(val as u16) }
}
#[inline]
pub fn set_enable_scatter(&mut self, val: u16) {
- let mask = 128usize as u16;
+ let mask = 128u64 as u16;
let val = val as u16 as u16;
- let mut unit_field_val: u16 =
- unsafe { ::std::mem::transmute(self._bitfield_1) };
+ let mut unit_field_val: u16 = unsafe { ::std::mem::uninitialized() };
+ unsafe {
+ ::std::ptr::copy_nonoverlapping(&self._bitfield_1 as *const _ as
+ *const u8,
+ &mut unit_field_val as *mut u16 as
+ *mut u8,
+ ::std::mem::size_of::<u16>())
+ };
unit_field_val &= !mask;
unit_field_val |= (val << 7usize) & mask;
- self._bitfield_1 = unsafe { ::std::mem::transmute(unit_field_val) };
+ unsafe {
+ ::std::ptr::copy_nonoverlapping(&unit_field_val as *const _ as
+ *const u8,
+ &mut self._bitfield_1 as *mut _ as
+ *mut u8,
+ ::std::mem::size_of::<u16>());
+ }
}
#[inline]
pub fn enable_lro(&self) -> u16 {
- let mask = 256usize as u16;
- let unit_field_val: u16 =
- unsafe { ::std::mem::transmute(self._bitfield_1) };
+ let mut unit_field_val: u16 = unsafe { ::std::mem::uninitialized() };
+ unsafe {
+ ::std::ptr::copy_nonoverlapping(&self._bitfield_1 as *const _ as
+ *const u8,
+ &mut unit_field_val as *mut u16 as
+ *mut u8,
+ ::std::mem::size_of::<u16>())
+ };
+ let mask = 256u64 as u16;
let val = (unit_field_val & mask) >> 8usize;
unsafe { ::std::mem::transmute(val as u16) }
}
#[inline]
pub fn set_enable_lro(&mut self, val: u16) {
- let mask = 256usize as u16;
+ let mask = 256u64 as u16;
let val = val as u16 as u16;
- let mut unit_field_val: u16 =
- unsafe { ::std::mem::transmute(self._bitfield_1) };
+ let mut unit_field_val: u16 = unsafe { ::std::mem::uninitialized() };
+ unsafe {
+ ::std::ptr::copy_nonoverlapping(&self._bitfield_1 as *const _ as
+ *const u8,
+ &mut unit_field_val as *mut u16 as
+ *mut u8,
+ ::std::mem::size_of::<u16>())
+ };
unit_field_val &= !mask;
unit_field_val |= (val << 8usize) & mask;
- self._bitfield_1 = unsafe { ::std::mem::transmute(unit_field_val) };
+ unsafe {
+ ::std::ptr::copy_nonoverlapping(&unit_field_val as *const _ as
+ *const u8,
+ &mut self._bitfield_1 as *mut _ as
+ *mut u8,
+ ::std::mem::size_of::<u16>());
+ }
}
#[inline]
pub fn new_bitfield_1(header_split: u16, hw_ip_checksum: u16,
@@ -298,30 +460,30 @@ impl rte_eth_rxmode {
({ 0 } |
((header_split as u16 as
u16) << 0usize) &
- (1usize as u16))
+ (1u64 as u16))
} |
((hw_ip_checksum as u16 as
u16) << 1usize) &
- (2usize as u16))
+ (2u64 as u16))
} |
((hw_vlan_filter as u16 as u16) <<
- 2usize) & (4usize as u16))
+ 2usize) & (4u64 as u16))
} |
((hw_vlan_strip as u16 as u16) <<
- 3usize) & (8usize as u16))
+ 3usize) & (8u64 as u16))
} |
((hw_vlan_extend as u16 as u16) << 4usize) &
- (16usize as u16))
+ (16u64 as u16))
} |
((jumbo_frame as u16 as u16) << 5usize) &
- (32usize as u16))
+ (32u64 as u16))
} |
((hw_strip_crc as u16 as u16) << 6usize) &
- (64usize as u16))
+ (64u64 as u16))
} |
((enable_scatter as u16 as u16) << 7usize) &
- (128usize as u16))
- } | ((enable_lro as u16 as u16) << 8usize) & (256usize as u16))
+ (128u64 as u16))
+ } | ((enable_lro as u16 as u16) << 8usize) & (256u64 as u16))
}
}
#[repr(u32)]
@@ -374,57 +536,111 @@ impl Default for rte_eth_txmode {
impl rte_eth_txmode {
#[inline]
pub fn hw_vlan_reject_tagged(&self) -> u8 {
- let mask = 1usize as u8;
- let unit_field_val: u8 =
- unsafe { ::std::mem::transmute(self._bitfield_1) };
+ let mut unit_field_val: u8 = unsafe { ::std::mem::uninitialized() };
+ unsafe {
+ ::std::ptr::copy_nonoverlapping(&self._bitfield_1 as *const _ as
+ *const u8,
+ &mut unit_field_val as *mut u8 as
+ *mut u8,
+ ::std::mem::size_of::<u8>())
+ };
+ let mask = 1u64 as u8;
let val = (unit_field_val & mask) >> 0usize;
unsafe { ::std::mem::transmute(val as u8) }
}
#[inline]
pub fn set_hw_vlan_reject_tagged(&mut self, val: u8) {
- let mask = 1usize as u8;
+ let mask = 1u64 as u8;
let val = val as u8 as u8;
- let mut unit_field_val: u8 =
- unsafe { ::std::mem::transmute(self._bitfield_1) };
+ let mut unit_field_val: u8 = unsafe { ::std::mem::uninitialized() };
+ unsafe {
+ ::std::ptr::copy_nonoverlapping(&self._bitfield_1 as *const _ as
+ *const u8,
+ &mut unit_field_val as *mut u8 as
+ *mut u8,
+ ::std::mem::size_of::<u8>())
+ };
unit_field_val &= !mask;
unit_field_val |= (val << 0usize) & mask;
- self._bitfield_1 = unsafe { ::std::mem::transmute(unit_field_val) };
+ unsafe {
+ ::std::ptr::copy_nonoverlapping(&unit_field_val as *const _ as
+ *const u8,
+ &mut self._bitfield_1 as *mut _ as
+ *mut u8,
+ ::std::mem::size_of::<u8>());
+ }
}
#[inline]
pub fn hw_vlan_reject_untagged(&self) -> u8 {
- let mask = 2usize as u8;
- let unit_field_val: u8 =
- unsafe { ::std::mem::transmute(self._bitfield_1) };
+ let mut unit_field_val: u8 = unsafe { ::std::mem::uninitialized() };
+ unsafe {
+ ::std::ptr::copy_nonoverlapping(&self._bitfield_1 as *const _ as
+ *const u8,
+ &mut unit_field_val as *mut u8 as
+ *mut u8,
+ ::std::mem::size_of::<u8>())
+ };
+ let mask = 2u64 as u8;
let val = (unit_field_val & mask) >> 1usize;
unsafe { ::std::mem::transmute(val as u8) }
}
#[inline]
pub fn set_hw_vlan_reject_untagged(&mut self, val: u8) {
- let mask = 2usize as u8;
+ let mask = 2u64 as u8;
let val = val as u8 as u8;
- let mut unit_field_val: u8 =
- unsafe { ::std::mem::transmute(self._bitfield_1) };
+ let mut unit_field_val: u8 = unsafe { ::std::mem::uninitialized() };
+ unsafe {
+ ::std::ptr::copy_nonoverlapping(&self._bitfield_1 as *const _ as
+ *const u8,
+ &mut unit_field_val as *mut u8 as
+ *mut u8,
+ ::std::mem::size_of::<u8>())
+ };
unit_field_val &= !mask;
unit_field_val |= (val << 1usize) & mask;
- self._bitfield_1 = unsafe { ::std::mem::transmute(unit_field_val) };
+ unsafe {
+ ::std::ptr::copy_nonoverlapping(&unit_field_val as *const _ as
+ *const u8,
+ &mut self._bitfield_1 as *mut _ as
+ *mut u8,
+ ::std::mem::size_of::<u8>());
+ }
}
#[inline]
pub fn hw_vlan_insert_pvid(&self) -> u8 {
- let mask = 4usize as u8;
- let unit_field_val: u8 =
- unsafe { ::std::mem::transmute(self._bitfield_1) };
+ let mut unit_field_val: u8 = unsafe { ::std::mem::uninitialized() };
+ unsafe {
+ ::std::ptr::copy_nonoverlapping(&self._bitfield_1 as *const _ as
+ *const u8,
+ &mut unit_field_val as *mut u8 as
+ *mut u8,
+ ::std::mem::size_of::<u8>())
+ };
+ let mask = 4u64 as u8;
let val = (unit_field_val & mask) >> 2usize;
unsafe { ::std::mem::transmute(val as u8) }
}
#[inline]
pub fn set_hw_vlan_insert_pvid(&mut self, val: u8) {
- let mask = 4usize as u8;
+ let mask = 4u64 as u8;
let val = val as u8 as u8;
- let mut unit_field_val: u8 =
- unsafe { ::std::mem::transmute(self._bitfield_1) };
+ let mut unit_field_val: u8 = unsafe { ::std::mem::uninitialized() };
+ unsafe {
+ ::std::ptr::copy_nonoverlapping(&self._bitfield_1 as *const _ as
+ *const u8,
+ &mut unit_field_val as *mut u8 as
+ *mut u8,
+ ::std::mem::size_of::<u8>())
+ };
unit_field_val &= !mask;
unit_field_val |= (val << 2usize) & mask;
- self._bitfield_1 = unsafe { ::std::mem::transmute(unit_field_val) };
+ unsafe {
+ ::std::ptr::copy_nonoverlapping(&unit_field_val as *const _ as
+ *const u8,
+ &mut self._bitfield_1 as *mut _ as
+ *mut u8,
+ ::std::mem::size_of::<u8>());
+ }
}
#[inline]
pub fn new_bitfield_1(hw_vlan_reject_tagged: u8,
@@ -434,11 +650,11 @@ impl rte_eth_txmode {
({
({ 0 } |
((hw_vlan_reject_tagged as u8 as u8) << 0usize) &
- (1usize as u8))
+ (1u64 as u8))
} |
((hw_vlan_reject_untagged as u8 as u8) << 1usize) &
- (2usize as u8))
- } | ((hw_vlan_insert_pvid as u8 as u8) << 2usize) & (4usize as u8))
+ (2u64 as u8))
+ } | ((hw_vlan_insert_pvid as u8 as u8) << 2usize) & (4u64 as u8))
}
}
/**
diff --git a/tests/expectations/tests/layout_mbuf.rs b/tests/expectations/tests/layout_mbuf.rs
index e0e95a1f..d0598e62 100644
--- a/tests/expectations/tests/layout_mbuf.rs
+++ b/tests/expectations/tests/layout_mbuf.rs
@@ -178,129 +178,255 @@ impl Clone for rte_mbuf__bindgen_ty_2__bindgen_ty_1 {
impl rte_mbuf__bindgen_ty_2__bindgen_ty_1 {
#[inline]
pub fn l2_type(&self) -> u32 {
- let mask = 15usize as u32;
- let unit_field_val: u32 =
- unsafe { ::std::mem::transmute(self._bitfield_1) };
+ let mut unit_field_val: u32 = unsafe { ::std::mem::uninitialized() };
+ unsafe {
+ ::std::ptr::copy_nonoverlapping(&self._bitfield_1 as *const _ as
+ *const u8,
+ &mut unit_field_val as *mut u32 as
+ *mut u8,
+ ::std::mem::size_of::<u32>())
+ };
+ let mask = 15u64 as u32;
let val = (unit_field_val & mask) >> 0usize;
unsafe { ::std::mem::transmute(val as u32) }
}
#[inline]
pub fn set_l2_type(&mut self, val: u32) {
- let mask = 15usize as u32;
+ let mask = 15u64 as u32;
let val = val as u32 as u32;
- let mut unit_field_val: u32 =
- unsafe { ::std::mem::transmute(self._bitfield_1) };
+ let mut unit_field_val: u32 = unsafe { ::std::mem::uninitialized() };
+ unsafe {
+ ::std::ptr::copy_nonoverlapping(&self._bitfield_1 as *const _ as
+ *const u8,
+ &mut unit_field_val as *mut u32 as
+ *mut u8,
+ ::std::mem::size_of::<u32>())
+ };
unit_field_val &= !mask;
unit_field_val |= (val << 0usize) & mask;
- self._bitfield_1 = unsafe { ::std::mem::transmute(unit_field_val) };
+ unsafe {
+ ::std::ptr::copy_nonoverlapping(&unit_field_val as *const _ as
+ *const u8,
+ &mut self._bitfield_1 as *mut _ as
+ *mut u8,
+ ::std::mem::size_of::<u32>());
+ }
}
#[inline]
pub fn l3_type(&self) -> u32 {
- let mask = 240usize as u32;
- let unit_field_val: u32 =
- unsafe { ::std::mem::transmute(self._bitfield_1) };
+ let mut unit_field_val: u32 = unsafe { ::std::mem::uninitialized() };
+ unsafe {
+ ::std::ptr::copy_nonoverlapping(&self._bitfield_1 as *const _ as
+ *const u8,
+ &mut unit_field_val as *mut u32 as
+ *mut u8,
+ ::std::mem::size_of::<u32>())
+ };
+ let mask = 240u64 as u32;
let val = (unit_field_val & mask) >> 4usize;
unsafe { ::std::mem::transmute(val as u32) }
}
#[inline]
pub fn set_l3_type(&mut self, val: u32) {
- let mask = 240usize as u32;
+ let mask = 240u64 as u32;
let val = val as u32 as u32;
- let mut unit_field_val: u32 =
- unsafe { ::std::mem::transmute(self._bitfield_1) };
+ let mut unit_field_val: u32 = unsafe { ::std::mem::uninitialized() };
+ unsafe {
+ ::std::ptr::copy_nonoverlapping(&self._bitfield_1 as *const _ as
+ *const u8,
+ &mut unit_field_val as *mut u32 as
+ *mut u8,
+ ::std::mem::size_of::<u32>())
+ };
unit_field_val &= !mask;
unit_field_val |= (val << 4usize) & mask;
- self._bitfield_1 = unsafe { ::std::mem::transmute(unit_field_val) };
+ unsafe {
+ ::std::ptr::copy_nonoverlapping(&unit_field_val as *const _ as
+ *const u8,
+ &mut self._bitfield_1 as *mut _ as
+ *mut u8,
+ ::std::mem::size_of::<u32>());
+ }
}
#[inline]
pub fn l4_type(&self) -> u32 {
- let mask = 3840usize as u32;
- let unit_field_val: u32 =
- unsafe { ::std::mem::transmute(self._bitfield_1) };
+ let mut unit_field_val: u32 = unsafe { ::std::mem::uninitialized() };
+ unsafe {
+ ::std::ptr::copy_nonoverlapping(&self._bitfield_1 as *const _ as
+ *const u8,
+ &mut unit_field_val as *mut u32 as
+ *mut u8,
+ ::std::mem::size_of::<u32>())
+ };
+ let mask = 3840u64 as u32;
let val = (unit_field_val & mask) >> 8usize;
unsafe { ::std::mem::transmute(val as u32) }
}
#[inline]
pub fn set_l4_type(&mut self, val: u32) {
- let mask = 3840usize as u32;
+ let mask = 3840u64 as u32;
let val = val as u32 as u32;
- let mut unit_field_val: u32 =
- unsafe { ::std::mem::transmute(self._bitfield_1) };
+ let mut unit_field_val: u32 = unsafe { ::std::mem::uninitialized() };
+ unsafe {
+ ::std::ptr::copy_nonoverlapping(&self._bitfield_1 as *const _ as
+ *const u8,
+ &mut unit_field_val as *mut u32 as
+ *mut u8,
+ ::std::mem::size_of::<u32>())
+ };
unit_field_val &= !mask;
unit_field_val |= (val << 8usize) & mask;
- self._bitfield_1 = unsafe { ::std::mem::transmute(unit_field_val) };
+ unsafe {
+ ::std::ptr::copy_nonoverlapping(&unit_field_val as *const _ as
+ *const u8,
+ &mut self._bitfield_1 as *mut _ as
+ *mut u8,
+ ::std::mem::size_of::<u32>());
+ }
}
#[inline]
pub fn tun_type(&self) -> u32 {
- let mask = 61440usize as u32;
- let unit_field_val: u32 =
- unsafe { ::std::mem::transmute(self._bitfield_1) };
+ let mut unit_field_val: u32 = unsafe { ::std::mem::uninitialized() };
+ unsafe {
+ ::std::ptr::copy_nonoverlapping(&self._bitfield_1 as *const _ as
+ *const u8,
+ &mut unit_field_val as *mut u32 as
+ *mut u8,
+ ::std::mem::size_of::<u32>())
+ };
+ let mask = 61440u64 as u32;
let val = (unit_field_val & mask) >> 12usize;
unsafe { ::std::mem::transmute(val as u32) }
}
#[inline]
pub fn set_tun_type(&mut self, val: u32) {
- let mask = 61440usize as u32;
+ let mask = 61440u64 as u32;
let val = val as u32 as u32;
- let mut unit_field_val: u32 =
- unsafe { ::std::mem::transmute(self._bitfield_1) };
+ let mut unit_field_val: u32 = unsafe { ::std::mem::uninitialized() };
+ unsafe {
+ ::std::ptr::copy_nonoverlapping(&self._bitfield_1 as *const _ as
+ *const u8,
+ &mut unit_field_val as *mut u32 as
+ *mut u8,
+ ::std::mem::size_of::<u32>())
+ };
unit_field_val &= !mask;
unit_field_val |= (val << 12usize) & mask;
- self._bitfield_1 = unsafe { ::std::mem::transmute(unit_field_val) };
+ unsafe {
+ ::std::ptr::copy_nonoverlapping(&unit_field_val as *const _ as
+ *const u8,
+ &mut self._bitfield_1 as *mut _ as
+ *mut u8,
+ ::std::mem::size_of::<u32>());
+ }
}
#[inline]
pub fn inner_l2_type(&self) -> u32 {
- let mask = 983040usize as u32;
- let unit_field_val: u32 =
- unsafe { ::std::mem::transmute(self._bitfield_1) };
+ let mut unit_field_val: u32 = unsafe { ::std::mem::uninitialized() };
+ unsafe {
+ ::std::ptr::copy_nonoverlapping(&self._bitfield_1 as *const _ as
+ *const u8,
+ &mut unit_field_val as *mut u32 as
+ *mut u8,
+ ::std::mem::size_of::<u32>())
+ };
+ let mask = 983040u64 as u32;
let val = (unit_field_val & mask) >> 16usize;
unsafe { ::std::mem::transmute(val as u32) }
}
#[inline]
pub fn set_inner_l2_type(&mut self, val: u32) {
- let mask = 983040usize as u32;
+ let mask = 983040u64 as u32;
let val = val as u32 as u32;
- let mut unit_field_val: u32 =
- unsafe { ::std::mem::transmute(self._bitfield_1) };
+ let mut unit_field_val: u32 = unsafe { ::std::mem::uninitialized() };
+ unsafe {
+ ::std::ptr::copy_nonoverlapping(&self._bitfield_1 as *const _ as
+ *const u8,
+ &mut unit_field_val as *mut u32 as
+ *mut u8,
+ ::std::mem::size_of::<u32>())
+ };
unit_field_val &= !mask;
unit_field_val |= (val << 16usize) & mask;
- self._bitfield_1 = unsafe { ::std::mem::transmute(unit_field_val) };
+ unsafe {
+ ::std::ptr::copy_nonoverlapping(&unit_field_val as *const _ as
+ *const u8,
+ &mut self._bitfield_1 as *mut _ as
+ *mut u8,
+ ::std::mem::size_of::<u32>());
+ }
}
#[inline]
pub fn inner_l3_type(&self) -> u32 {
- let mask = 15728640usize as u32;
- let unit_field_val: u32 =
- unsafe { ::std::mem::transmute(self._bitfield_1) };
+ let mut unit_field_val: u32 = unsafe { ::std::mem::uninitialized() };
+ unsafe {
+ ::std::ptr::copy_nonoverlapping(&self._bitfield_1 as *const _ as
+ *const u8,
+ &mut unit_field_val as *mut u32 as
+ *mut u8,
+ ::std::mem::size_of::<u32>())
+ };
+ let mask = 15728640u64 as u32;
let val = (unit_field_val & mask) >> 20usize;
unsafe { ::std::mem::transmute(val as u32) }
}
#[inline]
pub fn set_inner_l3_type(&mut self, val: u32) {
- let mask = 15728640usize as u32;
+ let mask = 15728640u64 as u32;
let val = val as u32 as u32;
- let mut unit_field_val: u32 =
- unsafe { ::std::mem::transmute(self._bitfield_1) };
+ let mut unit_field_val: u32 = unsafe { ::std::mem::uninitialized() };
+ unsafe {
+ ::std::ptr::copy_nonoverlapping(&self._bitfield_1 as *const _ as
+ *const u8,
+ &mut unit_field_val as *mut u32 as
+ *mut u8,
+ ::std::mem::size_of::<u32>())
+ };
unit_field_val &= !mask;
unit_field_val |= (val << 20usize) & mask;
- self._bitfield_1 = unsafe { ::std::mem::transmute(unit_field_val) };
+ unsafe {
+ ::std::ptr::copy_nonoverlapping(&unit_field_val as *const _ as
+ *const u8,
+ &mut self._bitfield_1 as *mut _ as
+ *mut u8,
+ ::std::mem::size_of::<u32>());
+ }
}
#[inline]
pub fn inner_l4_type(&self) -> u32 {
- let mask = 251658240usize as u32;
- let unit_field_val: u32 =
- unsafe { ::std::mem::transmute(self._bitfield_1) };
+ let mut unit_field_val: u32 = unsafe { ::std::mem::uninitialized() };
+ unsafe {
+ ::std::ptr::copy_nonoverlapping(&self._bitfield_1 as *const _ as
+ *const u8,
+ &mut unit_field_val as *mut u32 as
+ *mut u8,
+ ::std::mem::size_of::<u32>())
+ };
+ let mask = 251658240u64 as u32;
let val = (unit_field_val & mask) >> 24usize;
unsafe { ::std::mem::transmute(val as u32) }
}
#[inline]
pub fn set_inner_l4_type(&mut self, val: u32) {
- let mask = 251658240usize as u32;
+ let mask = 251658240u64 as u32;
let val = val as u32 as u32;
- let mut unit_field_val: u32 =
- unsafe { ::std::mem::transmute(self._bitfield_1) };
+ let mut unit_field_val: u32 = unsafe { ::std::mem::uninitialized() };
+ unsafe {
+ ::std::ptr::copy_nonoverlapping(&self._bitfield_1 as *const _ as
+ *const u8,
+ &mut unit_field_val as *mut u32 as
+ *mut u8,
+ ::std::mem::size_of::<u32>())
+ };
unit_field_val &= !mask;
unit_field_val |= (val << 24usize) & mask;
- self._bitfield_1 = unsafe { ::std::mem::transmute(unit_field_val) };
+ unsafe {
+ ::std::ptr::copy_nonoverlapping(&unit_field_val as *const _ as
+ *const u8,
+ &mut self._bitfield_1 as *mut _ as
+ *mut u8,
+ ::std::mem::size_of::<u32>());
+ }
}
#[inline]
pub fn new_bitfield_1(l2_type: u32, l3_type: u32, l4_type: u32,
@@ -314,25 +440,25 @@ impl rte_mbuf__bindgen_ty_2__bindgen_ty_1 {
({
({ 0 } |
((l2_type as u32 as u32) << 0usize)
- & (15usize as u32))
+ & (15u64 as u32))
} |
((l3_type as u32 as u32) << 4usize) &
- (240usize as u32))
+ (240u64 as u32))
} |
((l4_type as u32 as u32) << 8usize) &
- (3840usize as u32))
+ (3840u64 as u32))
} |
((tun_type as u32 as u32) << 12usize) &
- (61440usize as u32))
+ (61440u64 as u32))
} |
((inner_l2_type as u32 as u32) << 16usize) &
- (983040usize as u32))
+ (983040u64 as u32))
} |
((inner_l3_type as u32 as u32) << 20usize) &
- (15728640usize as u32))
+ (15728640u64 as u32))
} |
((inner_l4_type as u32 as u32) << 24usize) &
- (251658240usize as u32))
+ (251658240u64 as u32))
}
}
#[test]
@@ -588,111 +714,219 @@ impl Clone for rte_mbuf__bindgen_ty_5__bindgen_ty_1 {
impl rte_mbuf__bindgen_ty_5__bindgen_ty_1 {
#[inline]
pub fn l2_len(&self) -> u64 {
- let mask = 127usize as u64;
- let unit_field_val: u64 =
- unsafe { ::std::mem::transmute(self._bitfield_1) };
+ let mut unit_field_val: u64 = unsafe { ::std::mem::uninitialized() };
+ unsafe {
+ ::std::ptr::copy_nonoverlapping(&self._bitfield_1 as *const _ as
+ *const u8,
+ &mut unit_field_val as *mut u64 as
+ *mut u8,
+ ::std::mem::size_of::<u64>())
+ };
+ let mask = 127u64 as u64;
let val = (unit_field_val & mask) >> 0usize;
unsafe { ::std::mem::transmute(val as u64) }
}
#[inline]
pub fn set_l2_len(&mut self, val: u64) {
- let mask = 127usize as u64;
+ let mask = 127u64 as u64;
let val = val as u64 as u64;
- let mut unit_field_val: u64 =
- unsafe { ::std::mem::transmute(self._bitfield_1) };
+ let mut unit_field_val: u64 = unsafe { ::std::mem::uninitialized() };
+ unsafe {
+ ::std::ptr::copy_nonoverlapping(&self._bitfield_1 as *const _ as
+ *const u8,
+ &mut unit_field_val as *mut u64 as
+ *mut u8,
+ ::std::mem::size_of::<u64>())
+ };
unit_field_val &= !mask;
unit_field_val |= (val << 0usize) & mask;
- self._bitfield_1 = unsafe { ::std::mem::transmute(unit_field_val) };
+ unsafe {
+ ::std::ptr::copy_nonoverlapping(&unit_field_val as *const _ as
+ *const u8,
+ &mut self._bitfield_1 as *mut _ as
+ *mut u8,
+ ::std::mem::size_of::<u64>());
+ }
}
#[inline]
pub fn l3_len(&self) -> u64 {
- let mask = 65408usize as u64;
- let unit_field_val: u64 =
- unsafe { ::std::mem::transmute(self._bitfield_1) };
+ let mut unit_field_val: u64 = unsafe { ::std::mem::uninitialized() };
+ unsafe {
+ ::std::ptr::copy_nonoverlapping(&self._bitfield_1 as *const _ as
+ *const u8,
+ &mut unit_field_val as *mut u64 as
+ *mut u8,
+ ::std::mem::size_of::<u64>())
+ };
+ let mask = 65408u64 as u64;
let val = (unit_field_val & mask) >> 7usize;
unsafe { ::std::mem::transmute(val as u64) }
}
#[inline]
pub fn set_l3_len(&mut self, val: u64) {
- let mask = 65408usize as u64;
+ let mask = 65408u64 as u64;
let val = val as u64 as u64;
- let mut unit_field_val: u64 =
- unsafe { ::std::mem::transmute(self._bitfield_1) };
+ let mut unit_field_val: u64 = unsafe { ::std::mem::uninitialized() };
+ unsafe {
+ ::std::ptr::copy_nonoverlapping(&self._bitfield_1 as *const _ as
+ *const u8,
+ &mut unit_field_val as *mut u64 as
+ *mut u8,
+ ::std::mem::size_of::<u64>())
+ };
unit_field_val &= !mask;
unit_field_val |= (val << 7usize) & mask;
- self._bitfield_1 = unsafe { ::std::mem::transmute(unit_field_val) };
+ unsafe {
+ ::std::ptr::copy_nonoverlapping(&unit_field_val as *const _ as
+ *const u8,
+ &mut self._bitfield_1 as *mut _ as
+ *mut u8,
+ ::std::mem::size_of::<u64>());
+ }
}
#[inline]
pub fn l4_len(&self) -> u64 {
- let mask = 16711680usize as u64;
- let unit_field_val: u64 =
- unsafe { ::std::mem::transmute(self._bitfield_1) };
+ let mut unit_field_val: u64 = unsafe { ::std::mem::uninitialized() };
+ unsafe {
+ ::std::ptr::copy_nonoverlapping(&self._bitfield_1 as *const _ as
+ *const u8,
+ &mut unit_field_val as *mut u64 as
+ *mut u8,
+ ::std::mem::size_of::<u64>())
+ };
+ let mask = 16711680u64 as u64;
let val = (unit_field_val & mask) >> 16usize;
unsafe { ::std::mem::transmute(val as u64) }
}
#[inline]
pub fn set_l4_len(&mut self, val: u64) {
- let mask = 16711680usize as u64;
+ let mask = 16711680u64 as u64;
let val = val as u64 as u64;
- let mut unit_field_val: u64 =
- unsafe { ::std::mem::transmute(self._bitfield_1) };
+ let mut unit_field_val: u64 = unsafe { ::std::mem::uninitialized() };
+ unsafe {
+ ::std::ptr::copy_nonoverlapping(&self._bitfield_1 as *const _ as
+ *const u8,
+ &mut unit_field_val as *mut u64 as
+ *mut u8,
+ ::std::mem::size_of::<u64>())
+ };
unit_field_val &= !mask;
unit_field_val |= (val << 16usize) & mask;
- self._bitfield_1 = unsafe { ::std::mem::transmute(unit_field_val) };
+ unsafe {
+ ::std::ptr::copy_nonoverlapping(&unit_field_val as *const _ as
+ *const u8,
+ &mut self._bitfield_1 as *mut _ as
+ *mut u8,
+ ::std::mem::size_of::<u64>());
+ }
}
#[inline]
pub fn tso_segsz(&self) -> u64 {
- let mask = 1099494850560usize as u64;
- let unit_field_val: u64 =
- unsafe { ::std::mem::transmute(self._bitfield_1) };
+ let mut unit_field_val: u64 = unsafe { ::std::mem::uninitialized() };
+ unsafe {
+ ::std::ptr::copy_nonoverlapping(&self._bitfield_1 as *const _ as
+ *const u8,
+ &mut unit_field_val as *mut u64 as
+ *mut u8,
+ ::std::mem::size_of::<u64>())
+ };
+ let mask = 1099494850560u64 as u64;
let val = (unit_field_val & mask) >> 24usize;
unsafe { ::std::mem::transmute(val as u64) }
}
#[inline]
pub fn set_tso_segsz(&mut self, val: u64) {
- let mask = 1099494850560usize as u64;
+ let mask = 1099494850560u64 as u64;
let val = val as u64 as u64;
- let mut unit_field_val: u64 =
- unsafe { ::std::mem::transmute(self._bitfield_1) };
+ let mut unit_field_val: u64 = unsafe { ::std::mem::uninitialized() };
+ unsafe {
+ ::std::ptr::copy_nonoverlapping(&self._bitfield_1 as *const _ as
+ *const u8,
+ &mut unit_field_val as *mut u64 as
+ *mut u8,
+ ::std::mem::size_of::<u64>())
+ };
unit_field_val &= !mask;
unit_field_val |= (val << 24usize) & mask;
- self._bitfield_1 = unsafe { ::std::mem::transmute(unit_field_val) };
+ unsafe {
+ ::std::ptr::copy_nonoverlapping(&unit_field_val as *const _ as
+ *const u8,
+ &mut self._bitfield_1 as *mut _ as
+ *mut u8,
+ ::std::mem::size_of::<u64>());
+ }
}
#[inline]
pub fn outer_l3_len(&self) -> u64 {
- let mask = 561850441793536usize as u64;
- let unit_field_val: u64 =
- unsafe { ::std::mem::transmute(self._bitfield_1) };
+ let mut unit_field_val: u64 = unsafe { ::std::mem::uninitialized() };
+ unsafe {
+ ::std::ptr::copy_nonoverlapping(&self._bitfield_1 as *const _ as
+ *const u8,
+ &mut unit_field_val as *mut u64 as
+ *mut u8,
+ ::std::mem::size_of::<u64>())
+ };
+ let mask = 561850441793536u64 as u64;
let val = (unit_field_val & mask) >> 40usize;
unsafe { ::std::mem::transmute(val as u64) }
}
#[inline]
pub fn set_outer_l3_len(&mut self, val: u64) {
- let mask = 561850441793536usize as u64;
+ let mask = 561850441793536u64 as u64;
let val = val as u64 as u64;
- let mut unit_field_val: u64 =
- unsafe { ::std::mem::transmute(self._bitfield_1) };
+ let mut unit_field_val: u64 = unsafe { ::std::mem::uninitialized() };
+ unsafe {
+ ::std::ptr::copy_nonoverlapping(&self._bitfield_1 as *const _ as
+ *const u8,
+ &mut unit_field_val as *mut u64 as
+ *mut u8,
+ ::std::mem::size_of::<u64>())
+ };
unit_field_val &= !mask;
unit_field_val |= (val << 40usize) & mask;
- self._bitfield_1 = unsafe { ::std::mem::transmute(unit_field_val) };
+ unsafe {
+ ::std::ptr::copy_nonoverlapping(&unit_field_val as *const _ as
+ *const u8,
+ &mut self._bitfield_1 as *mut _ as
+ *mut u8,
+ ::std::mem::size_of::<u64>());
+ }
}
#[inline]
pub fn outer_l2_len(&self) -> u64 {
- let mask = 71494644084506624usize as u64;
- let unit_field_val: u64 =
- unsafe { ::std::mem::transmute(self._bitfield_1) };
+ let mut unit_field_val: u64 = unsafe { ::std::mem::uninitialized() };
+ unsafe {
+ ::std::ptr::copy_nonoverlapping(&self._bitfield_1 as *const _ as
+ *const u8,
+ &mut unit_field_val as *mut u64 as
+ *mut u8,
+ ::std::mem::size_of::<u64>())
+ };
+ let mask = 71494644084506624u64 as u64;
let val = (unit_field_val & mask) >> 49usize;
unsafe { ::std::mem::transmute(val as u64) }
}
#[inline]
pub fn set_outer_l2_len(&mut self, val: u64) {
- let mask = 71494644084506624usize as u64;
+ let mask = 71494644084506624u64 as u64;
let val = val as u64 as u64;
- let mut unit_field_val: u64 =
- unsafe { ::std::mem::transmute(self._bitfield_1) };
+ let mut unit_field_val: u64 = unsafe { ::std::mem::uninitialized() };
+ unsafe {
+ ::std::ptr::copy_nonoverlapping(&self._bitfield_1 as *const _ as
+ *const u8,
+ &mut unit_field_val as *mut u64 as
+ *mut u8,
+ ::std::mem::size_of::<u64>())
+ };
unit_field_val &= !mask;
unit_field_val |= (val << 49usize) & mask;
- self._bitfield_1 = unsafe { ::std::mem::transmute(unit_field_val) };
+ unsafe {
+ ::std::ptr::copy_nonoverlapping(&unit_field_val as *const _ as
+ *const u8,
+ &mut self._bitfield_1 as *mut _ as
+ *mut u8,
+ ::std::mem::size_of::<u64>());
+ }
}
#[inline]
pub fn new_bitfield_1(l2_len: u64, l3_len: u64, l4_len: u64,
@@ -705,22 +939,22 @@ impl rte_mbuf__bindgen_ty_5__bindgen_ty_1 {
({
({ 0 } |
((l2_len as u64 as u64) << 0usize) &
- (127usize as u64))
+ (127u64 as u64))
} |
((l3_len as u64 as u64) << 7usize) &
- (65408usize as u64))
+ (65408u64 as u64))
} |
((l4_len as u64 as u64) << 16usize) &
- (16711680usize as u64))
+ (16711680u64 as u64))
} |
((tso_segsz as u64 as u64) << 24usize) &
- (1099494850560usize as u64))
+ (1099494850560u64 as u64))
} |
((outer_l3_len as u64 as u64) << 40usize) &
- (561850441793536usize as u64))
+ (561850441793536u64 as u64))
} |
((outer_l2_len as u64 as u64) << 49usize) &
- (71494644084506624usize as u64))
+ (71494644084506624u64 as u64))
}
}
#[test]
diff --git a/tests/expectations/tests/libclang-3.8/issue-769-bad-instantiation-test.rs b/tests/expectations/tests/libclang-3.8/issue-769-bad-instantiation-test.rs
new file mode 100644
index 00000000..848e649f
--- /dev/null
+++ b/tests/expectations/tests/libclang-3.8/issue-769-bad-instantiation-test.rs
@@ -0,0 +1,42 @@
+/* automatically generated by rust-bindgen */
+
+
+#![allow(dead_code, non_snake_case, non_camel_case_types, non_upper_case_globals)]
+
+
+#[allow(non_snake_case, non_camel_case_types, non_upper_case_globals)]
+pub mod root {
+ #[allow(unused_imports)]
+ use self::super::root;
+ #[repr(C)]
+ #[derive(Debug, Copy, Clone)]
+ pub struct Rooted<T> {
+ pub member: T,
+ pub _phantom_0: ::std::marker::PhantomData<::std::cell::UnsafeCell<T>>,
+ }
+ impl <T> Default for Rooted<T> {
+ fn default() -> Self { unsafe { ::std::mem::zeroed() } }
+ }
+ #[test]
+ fn __bindgen_test_layout_Rooted_instantiation() {
+ assert_eq!(::std::mem::size_of::<root::Rooted<::std::os::raw::c_int>>()
+ , 4usize , concat ! (
+ "Size of template specialization: " , stringify ! (
+ root::Rooted<::std::os::raw::c_int> ) ));
+ assert_eq!(::std::mem::align_of::<root::Rooted<::std::os::raw::c_int>>()
+ , 4usize , concat ! (
+ "Alignment of template specialization: " , stringify ! (
+ root::Rooted<::std::os::raw::c_int> ) ));
+ }
+ #[test]
+ fn __bindgen_test_layout_Rooted_instantiation_1() {
+ assert_eq!(::std::mem::size_of::<root::Rooted<::std::os::raw::c_int>>()
+ , 4usize , concat ! (
+ "Size of template specialization: " , stringify ! (
+ root::Rooted<::std::os::raw::c_int> ) ));
+ assert_eq!(::std::mem::align_of::<root::Rooted<::std::os::raw::c_int>>()
+ , 4usize , concat ! (
+ "Alignment of template specialization: " , stringify ! (
+ root::Rooted<::std::os::raw::c_int> ) ));
+ }
+}
diff --git a/tests/expectations/tests/libclang-3.8/partial-specialization-and-inheritance.rs b/tests/expectations/tests/libclang-3.8/partial-specialization-and-inheritance.rs
index e7e9572f..6ca0d2d2 100644
--- a/tests/expectations/tests/libclang-3.8/partial-specialization-and-inheritance.rs
+++ b/tests/expectations/tests/libclang-3.8/partial-specialization-and-inheritance.rs
@@ -14,15 +14,6 @@ pub struct Base {
pub struct Derived {
pub b: bool,
}
-#[test]
-fn __bindgen_test_layout__bindgen_ty_id_21_instantiation_1() {
- assert_eq!(::std::mem::size_of::<[u32; 2usize]>() , 8usize , concat ! (
- "Size of template specialization: " , stringify ! (
- [u32; 2usize] ) ));
- assert_eq!(::std::mem::align_of::<[u32; 2usize]>() , 4usize , concat ! (
- "Alignment of template specialization: " , stringify ! (
- [u32; 2usize] ) ));
-}
#[repr(C)]
#[derive(Debug, Default, Copy)]
pub struct Usage {
@@ -54,3 +45,12 @@ impl Usage {
__bindgen_tmp
}
}
+#[test]
+fn __bindgen_test_layout__bindgen_ty_id_21_instantiation() {
+ assert_eq!(::std::mem::size_of::<[u32; 2usize]>() , 8usize , concat ! (
+ "Size of template specialization: " , stringify ! (
+ [u32; 2usize] ) ));
+ assert_eq!(::std::mem::align_of::<[u32; 2usize]>() , 4usize , concat ! (
+ "Alignment of template specialization: " , stringify ! (
+ [u32; 2usize] ) ));
+}
diff --git a/tests/expectations/tests/libclang-3.9/issue-769-bad-instantiation-test.rs b/tests/expectations/tests/libclang-3.9/issue-769-bad-instantiation-test.rs
new file mode 100644
index 00000000..848e649f
--- /dev/null
+++ b/tests/expectations/tests/libclang-3.9/issue-769-bad-instantiation-test.rs
@@ -0,0 +1,42 @@
+/* automatically generated by rust-bindgen */
+
+
+#![allow(dead_code, non_snake_case, non_camel_case_types, non_upper_case_globals)]
+
+
+#[allow(non_snake_case, non_camel_case_types, non_upper_case_globals)]
+pub mod root {
+ #[allow(unused_imports)]
+ use self::super::root;
+ #[repr(C)]
+ #[derive(Debug, Copy, Clone)]
+ pub struct Rooted<T> {
+ pub member: T,
+ pub _phantom_0: ::std::marker::PhantomData<::std::cell::UnsafeCell<T>>,
+ }
+ impl <T> Default for Rooted<T> {
+ fn default() -> Self { unsafe { ::std::mem::zeroed() } }
+ }
+ #[test]
+ fn __bindgen_test_layout_Rooted_instantiation() {
+ assert_eq!(::std::mem::size_of::<root::Rooted<::std::os::raw::c_int>>()
+ , 4usize , concat ! (
+ "Size of template specialization: " , stringify ! (
+ root::Rooted<::std::os::raw::c_int> ) ));
+ assert_eq!(::std::mem::align_of::<root::Rooted<::std::os::raw::c_int>>()
+ , 4usize , concat ! (
+ "Alignment of template specialization: " , stringify ! (
+ root::Rooted<::std::os::raw::c_int> ) ));
+ }
+ #[test]
+ fn __bindgen_test_layout_Rooted_instantiation_1() {
+ assert_eq!(::std::mem::size_of::<root::Rooted<::std::os::raw::c_int>>()
+ , 4usize , concat ! (
+ "Size of template specialization: " , stringify ! (
+ root::Rooted<::std::os::raw::c_int> ) ));
+ assert_eq!(::std::mem::align_of::<root::Rooted<::std::os::raw::c_int>>()
+ , 4usize , concat ! (
+ "Alignment of template specialization: " , stringify ! (
+ root::Rooted<::std::os::raw::c_int> ) ));
+ }
+}
diff --git a/tests/expectations/tests/libclang-3.9/partial-specialization-and-inheritance.rs b/tests/expectations/tests/libclang-3.9/partial-specialization-and-inheritance.rs
index ec399304..c0251371 100644
--- a/tests/expectations/tests/libclang-3.9/partial-specialization-and-inheritance.rs
+++ b/tests/expectations/tests/libclang-3.9/partial-specialization-and-inheritance.rs
@@ -14,15 +14,6 @@ pub struct Base {
pub struct Derived {
pub b: bool,
}
-#[test]
-fn __bindgen_test_layout__bindgen_ty_id_20_instantiation_1() {
- assert_eq!(::std::mem::size_of::<[u32; 2usize]>() , 8usize , concat ! (
- "Size of template specialization: " , stringify ! (
- [u32; 2usize] ) ));
- assert_eq!(::std::mem::align_of::<[u32; 2usize]>() , 4usize , concat ! (
- "Alignment of template specialization: " , stringify ! (
- [u32; 2usize] ) ));
-}
#[repr(C)]
#[derive(Debug, Default, Copy)]
pub struct Usage {
@@ -42,3 +33,12 @@ fn bindgen_test_layout_Usage() {
impl Clone for Usage {
fn clone(&self) -> Self { *self }
}
+#[test]
+fn __bindgen_test_layout__bindgen_ty_id_20_instantiation() {
+ assert_eq!(::std::mem::size_of::<[u32; 2usize]>() , 8usize , concat ! (
+ "Size of template specialization: " , stringify ! (
+ [u32; 2usize] ) ));
+ assert_eq!(::std::mem::align_of::<[u32; 2usize]>() , 4usize , concat ! (
+ "Alignment of template specialization: " , stringify ! (
+ [u32; 2usize] ) ));
+}
diff --git a/tests/expectations/tests/libclang-4/issue-769-bad-instantiation-test.rs b/tests/expectations/tests/libclang-4/issue-769-bad-instantiation-test.rs
new file mode 100644
index 00000000..f797cdff
--- /dev/null
+++ b/tests/expectations/tests/libclang-4/issue-769-bad-instantiation-test.rs
@@ -0,0 +1,43 @@
+/* automatically generated by rust-bindgen */
+
+
+#![allow(dead_code, non_snake_case, non_camel_case_types, non_upper_case_globals)]
+
+
+#[allow(non_snake_case, non_camel_case_types, non_upper_case_globals)]
+pub mod root {
+ #[allow(unused_imports)]
+ use self::super::root;
+ #[repr(C)]
+ #[derive(Debug, Copy, Clone)]
+ pub struct Rooted<T> {
+ pub member: T,
+ pub _phantom_0: ::std::marker::PhantomData<::std::cell::UnsafeCell<T>>,
+ }
+ impl <T> Default for Rooted<T> {
+ fn default() -> Self { unsafe { ::std::mem::zeroed() } }
+ }
+ pub type AutoValueVector_Alias = ::std::os::raw::c_int;
+ #[test]
+ fn __bindgen_test_layout_Rooted_instantiation() {
+ assert_eq!(::std::mem::size_of::<root::Rooted<::std::os::raw::c_int>>()
+ , 4usize , concat ! (
+ "Size of template specialization: " , stringify ! (
+ root::Rooted<::std::os::raw::c_int> ) ));
+ assert_eq!(::std::mem::align_of::<root::Rooted<::std::os::raw::c_int>>()
+ , 4usize , concat ! (
+ "Alignment of template specialization: " , stringify ! (
+ root::Rooted<::std::os::raw::c_int> ) ));
+ }
+ #[test]
+ fn __bindgen_test_layout_Rooted_instantiation_1() {
+ assert_eq!(::std::mem::size_of::<root::Rooted<root::AutoValueVector_Alias>>()
+ , 4usize , concat ! (
+ "Size of template specialization: " , stringify ! (
+ root::Rooted<root::AutoValueVector_Alias> ) ));
+ assert_eq!(::std::mem::align_of::<root::Rooted<root::AutoValueVector_Alias>>()
+ , 4usize , concat ! (
+ "Alignment of template specialization: " , stringify ! (
+ root::Rooted<root::AutoValueVector_Alias> ) ));
+ }
+}
diff --git a/tests/expectations/tests/libclang-4/partial-specialization-and-inheritance.rs b/tests/expectations/tests/libclang-4/partial-specialization-and-inheritance.rs
index ec399304..c0251371 100644
--- a/tests/expectations/tests/libclang-4/partial-specialization-and-inheritance.rs
+++ b/tests/expectations/tests/libclang-4/partial-specialization-and-inheritance.rs
@@ -14,15 +14,6 @@ pub struct Base {
pub struct Derived {
pub b: bool,
}
-#[test]
-fn __bindgen_test_layout__bindgen_ty_id_20_instantiation_1() {
- assert_eq!(::std::mem::size_of::<[u32; 2usize]>() , 8usize , concat ! (
- "Size of template specialization: " , stringify ! (
- [u32; 2usize] ) ));
- assert_eq!(::std::mem::align_of::<[u32; 2usize]>() , 4usize , concat ! (
- "Alignment of template specialization: " , stringify ! (
- [u32; 2usize] ) ));
-}
#[repr(C)]
#[derive(Debug, Default, Copy)]
pub struct Usage {
@@ -42,3 +33,12 @@ fn bindgen_test_layout_Usage() {
impl Clone for Usage {
fn clone(&self) -> Self { *self }
}
+#[test]
+fn __bindgen_test_layout__bindgen_ty_id_20_instantiation() {
+ assert_eq!(::std::mem::size_of::<[u32; 2usize]>() , 8usize , concat ! (
+ "Size of template specialization: " , stringify ! (
+ [u32; 2usize] ) ));
+ assert_eq!(::std::mem::align_of::<[u32; 2usize]>() , 4usize , concat ! (
+ "Alignment of template specialization: " , stringify ! (
+ [u32; 2usize] ) ));
+}
diff --git a/tests/expectations/tests/libclang-4/type_alias_template_specialized.rs b/tests/expectations/tests/libclang-4/type_alias_template_specialized.rs
index e88178cf..19e2a0dd 100644
--- a/tests/expectations/tests/libclang-4/type_alias_template_specialized.rs
+++ b/tests/expectations/tests/libclang-4/type_alias_template_specialized.rs
@@ -29,3 +29,14 @@ impl Default for Rooted {
}
/// <div rustbindgen replaces="MaybeWrapped"></div>
pub type MaybeWrapped<a> = a;
+#[test]
+fn __bindgen_test_layout_MaybeWrapped_instantiation() {
+ assert_eq!(::std::mem::size_of::<MaybeWrapped<::std::os::raw::c_int>>() ,
+ 4usize , concat ! (
+ "Size of template specialization: " , stringify ! (
+ MaybeWrapped<::std::os::raw::c_int> ) ));
+ assert_eq!(::std::mem::align_of::<MaybeWrapped<::std::os::raw::c_int>>() ,
+ 4usize , concat ! (
+ "Alignment of template specialization: " , stringify ! (
+ MaybeWrapped<::std::os::raw::c_int> ) ));
+}
diff --git a/tests/expectations/tests/macro-expr-uncommon-token.rs b/tests/expectations/tests/macro-expr-uncommon-token.rs
new file mode 100644
index 00000000..d0d515a4
--- /dev/null
+++ b/tests/expectations/tests/macro-expr-uncommon-token.rs
@@ -0,0 +1,10 @@
+/* automatically generated by rust-bindgen */
+
+
+#![allow(dead_code, non_snake_case, non_camel_case_types, non_upper_case_globals)]
+
+
+pub const MODBUS_WOOT: ::std::os::raw::c_uint = 3;
+extern "C" {
+ pub fn foo();
+}
diff --git a/tests/expectations/tests/mangling-macos.rs b/tests/expectations/tests/mangling-macos.rs
new file mode 100644
index 00000000..87df5e4a
--- /dev/null
+++ b/tests/expectations/tests/mangling-macos.rs
@@ -0,0 +1,9 @@
+/* automatically generated by rust-bindgen */
+
+
+#![allow(dead_code, non_snake_case, non_camel_case_types, non_upper_case_globals)]
+
+
+extern "C" {
+ pub fn foo();
+}
diff --git a/tests/expectations/tests/mangling-win32.rs b/tests/expectations/tests/mangling-win32.rs
new file mode 100644
index 00000000..87df5e4a
--- /dev/null
+++ b/tests/expectations/tests/mangling-win32.rs
@@ -0,0 +1,9 @@
+/* automatically generated by rust-bindgen */
+
+
+#![allow(dead_code, non_snake_case, non_camel_case_types, non_upper_case_globals)]
+
+
+extern "C" {
+ pub fn foo();
+}
diff --git a/tests/expectations/tests/nested_vtable.rs b/tests/expectations/tests/nested_vtable.rs
index dae737d4..470fee41 100644
--- a/tests/expectations/tests/nested_vtable.rs
+++ b/tests/expectations/tests/nested_vtable.rs
@@ -24,6 +24,11 @@ impl Clone for nsISupports {
impl Default for nsISupports {
fn default() -> Self { unsafe { ::std::mem::zeroed() } }
}
+extern "C" {
+ #[link_name = "_ZN11nsISupports14QueryInterfaceEv"]
+ pub fn nsISupports_QueryInterface(this: *mut ::std::os::raw::c_void)
+ -> *mut nsISupports;
+}
#[repr(C)]
#[derive(Debug, Copy)]
pub struct nsIRunnable {
diff --git a/tests/expectations/tests/non-type-params.rs b/tests/expectations/tests/non-type-params.rs
index c7ac4e85..34864993 100644
--- a/tests/expectations/tests/non-type-params.rs
+++ b/tests/expectations/tests/non-type-params.rs
@@ -38,7 +38,7 @@ impl Default for UsesArray {
fn default() -> Self { unsafe { ::std::mem::zeroed() } }
}
#[test]
-fn __bindgen_test_layout_Array_instantiation_1() {
+fn __bindgen_test_layout_Array_instantiation() {
assert_eq!(::std::mem::size_of::<[u32; 4usize]>() , 16usize , concat ! (
"Size of template specialization: " , stringify ! (
[u32; 4usize] ) ));
@@ -46,3 +46,21 @@ fn __bindgen_test_layout_Array_instantiation_1() {
"Alignment of template specialization: " , stringify ! (
[u32; 4usize] ) ));
}
+#[test]
+fn __bindgen_test_layout_Array_instantiation_1() {
+ assert_eq!(::std::mem::size_of::<[u8; 16usize]>() , 16usize , concat ! (
+ "Size of template specialization: " , stringify ! (
+ [u8; 16usize] ) ));
+ assert_eq!(::std::mem::align_of::<[u8; 16usize]>() , 1usize , concat ! (
+ "Alignment of template specialization: " , stringify ! (
+ [u8; 16usize] ) ));
+}
+#[test]
+fn __bindgen_test_layout_Array_instantiation_2() {
+ assert_eq!(::std::mem::size_of::<[u8; 8usize]>() , 8usize , concat ! (
+ "Size of template specialization: " , stringify ! (
+ [u8; 8usize] ) ));
+ assert_eq!(::std::mem::align_of::<[u8; 8usize]>() , 1usize , concat ! (
+ "Alignment of template specialization: " , stringify ! (
+ [u8; 8usize] ) ));
+}
diff --git a/tests/expectations/tests/only_bitfields.rs b/tests/expectations/tests/only_bitfields.rs
index a47a466c..64a1fd79 100644
--- a/tests/expectations/tests/only_bitfields.rs
+++ b/tests/expectations/tests/only_bitfields.rs
@@ -23,43 +23,79 @@ impl Clone for C {
impl C {
#[inline]
pub fn a(&self) -> bool {
- let mask = 1usize as u8;
- let unit_field_val: u8 =
- unsafe { ::std::mem::transmute(self._bitfield_1) };
+ let mut unit_field_val: u8 = unsafe { ::std::mem::uninitialized() };
+ unsafe {
+ ::std::ptr::copy_nonoverlapping(&self._bitfield_1 as *const _ as
+ *const u8,
+ &mut unit_field_val as *mut u8 as
+ *mut u8,
+ ::std::mem::size_of::<u8>())
+ };
+ let mask = 1u64 as u8;
let val = (unit_field_val & mask) >> 0usize;
unsafe { ::std::mem::transmute(val as u8) }
}
#[inline]
pub fn set_a(&mut self, val: bool) {
- let mask = 1usize as u8;
+ let mask = 1u64 as u8;
let val = val as u8 as u8;
- let mut unit_field_val: u8 =
- unsafe { ::std::mem::transmute(self._bitfield_1) };
+ let mut unit_field_val: u8 = unsafe { ::std::mem::uninitialized() };
+ unsafe {
+ ::std::ptr::copy_nonoverlapping(&self._bitfield_1 as *const _ as
+ *const u8,
+ &mut unit_field_val as *mut u8 as
+ *mut u8,
+ ::std::mem::size_of::<u8>())
+ };
unit_field_val &= !mask;
unit_field_val |= (val << 0usize) & mask;
- self._bitfield_1 = unsafe { ::std::mem::transmute(unit_field_val) };
+ unsafe {
+ ::std::ptr::copy_nonoverlapping(&unit_field_val as *const _ as
+ *const u8,
+ &mut self._bitfield_1 as *mut _ as
+ *mut u8,
+ ::std::mem::size_of::<u8>());
+ }
}
#[inline]
pub fn b(&self) -> bool {
- let mask = 254usize as u8;
- let unit_field_val: u8 =
- unsafe { ::std::mem::transmute(self._bitfield_1) };
+ let mut unit_field_val: u8 = unsafe { ::std::mem::uninitialized() };
+ unsafe {
+ ::std::ptr::copy_nonoverlapping(&self._bitfield_1 as *const _ as
+ *const u8,
+ &mut unit_field_val as *mut u8 as
+ *mut u8,
+ ::std::mem::size_of::<u8>())
+ };
+ let mask = 254u64 as u8;
let val = (unit_field_val & mask) >> 1usize;
unsafe { ::std::mem::transmute(val as u8) }
}
#[inline]
pub fn set_b(&mut self, val: bool) {
- let mask = 254usize as u8;
+ let mask = 254u64 as u8;
let val = val as u8 as u8;
- let mut unit_field_val: u8 =
- unsafe { ::std::mem::transmute(self._bitfield_1) };
+ let mut unit_field_val: u8 = unsafe { ::std::mem::uninitialized() };
+ unsafe {
+ ::std::ptr::copy_nonoverlapping(&self._bitfield_1 as *const _ as
+ *const u8,
+ &mut unit_field_val as *mut u8 as
+ *mut u8,
+ ::std::mem::size_of::<u8>())
+ };
unit_field_val &= !mask;
unit_field_val |= (val << 1usize) & mask;
- self._bitfield_1 = unsafe { ::std::mem::transmute(unit_field_val) };
+ unsafe {
+ ::std::ptr::copy_nonoverlapping(&unit_field_val as *const _ as
+ *const u8,
+ &mut self._bitfield_1 as *mut _ as
+ *mut u8,
+ ::std::mem::size_of::<u8>());
+ }
}
#[inline]
pub fn new_bitfield_1(a: bool, b: bool) -> u8 {
- ({ ({ 0 } | ((a as u8 as u8) << 0usize) & (1usize as u8)) } |
- ((b as u8 as u8) << 1usize) & (254usize as u8))
+ ({ ({ 0 } | ((a as u8 as u8) << 0usize) & (1u64 as u8)) } |
+ ((b as u8 as u8) << 1usize) & (254u64 as u8))
}
}
diff --git a/tests/expectations/tests/opaque_pointer.rs b/tests/expectations/tests/opaque_pointer.rs
index 3462f4c3..1222b374 100644
--- a/tests/expectations/tests/opaque_pointer.rs
+++ b/tests/expectations/tests/opaque_pointer.rs
@@ -67,3 +67,11 @@ impl Clone for WithOpaquePtr {
impl Default for WithOpaquePtr {
fn default() -> Self { unsafe { ::std::mem::zeroed() } }
}
+#[test]
+fn __bindgen_test_layout_Opaque_instantiation() {
+ assert_eq!(::std::mem::size_of::<u32>() , 4usize , concat ! (
+ "Size of template specialization: " , stringify ! ( u32 ) ));
+ assert_eq!(::std::mem::align_of::<u32>() , 4usize , concat ! (
+ "Alignment of template specialization: " , stringify ! ( u32 )
+ ));
+}
diff --git a/tests/expectations/tests/prepend-enum-constified-variant.rs b/tests/expectations/tests/prepend-enum-constified-variant.rs
new file mode 100644
index 00000000..d5dca70c
--- /dev/null
+++ b/tests/expectations/tests/prepend-enum-constified-variant.rs
@@ -0,0 +1,10 @@
+/* automatically generated by rust-bindgen */
+
+
+#![allow(dead_code, non_snake_case, non_camel_case_types, non_upper_case_globals)]
+
+
+pub const AV_CODEC_ID_TTF: AVCodecID = AVCodecID::AV_CODEC_ID_FIRST_UNKNOWN;
+#[repr(u32)]
+#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)]
+pub enum AVCodecID { AV_CODEC_ID_FIRST_UNKNOWN = 98304, }
diff --git a/tests/expectations/tests/ref_argument_array.rs b/tests/expectations/tests/ref_argument_array.rs
index 25187918..dc1465c3 100644
--- a/tests/expectations/tests/ref_argument_array.rs
+++ b/tests/expectations/tests/ref_argument_array.rs
@@ -25,3 +25,9 @@ impl Clone for nsID {
impl Default for nsID {
fn default() -> Self { unsafe { ::std::mem::zeroed() } }
}
+extern "C" {
+ #[link_name = "_ZN4nsID16ToProvidedStringERA10_c"]
+ pub fn nsID_ToProvidedString(this: *mut ::std::os::raw::c_void,
+ aDest:
+ *mut [::std::os::raw::c_char; 10usize]);
+}
diff --git a/tests/expectations/tests/replace_use.rs b/tests/expectations/tests/replace_use.rs
index 0c35be56..4d313530 100644
--- a/tests/expectations/tests/replace_use.rs
+++ b/tests/expectations/tests/replace_use.rs
@@ -35,3 +35,12 @@ impl Clone for Test {
impl Default for Test {
fn default() -> Self { unsafe { ::std::mem::zeroed() } }
}
+#[test]
+fn __bindgen_test_layout_nsTArray_instantiation() {
+ assert_eq!(::std::mem::size_of::<nsTArray>() , 4usize , concat ! (
+ "Size of template specialization: " , stringify ! ( nsTArray )
+ ));
+ assert_eq!(::std::mem::align_of::<nsTArray>() , 4usize , concat ! (
+ "Alignment of template specialization: " , stringify ! (
+ nsTArray ) ));
+}
diff --git a/tests/expectations/tests/replaces_double.rs b/tests/expectations/tests/replaces_double.rs
index aab511ec..b2670893 100644
--- a/tests/expectations/tests/replaces_double.rs
+++ b/tests/expectations/tests/replaces_double.rs
@@ -6,6 +6,16 @@
#[repr(C)]
#[derive(Debug, Copy, Clone)]
+pub struct Wrapper_Wrapped<T> {
+ pub t: T,
+ pub _phantom_0: ::std::marker::PhantomData<::std::cell::UnsafeCell<T>>,
+}
+impl <T> Default for Wrapper_Wrapped<T> {
+ fn default() -> Self { unsafe { ::std::mem::zeroed() } }
+}
+pub type Wrapper_Type<T> = Wrapper_Wrapped<T>;
+#[repr(C)]
+#[derive(Debug, Copy, Clone)]
pub struct Rooted<T> {
pub ptr: Rooted_MaybeWrapped<T>,
pub _phantom_0: ::std::marker::PhantomData<::std::cell::UnsafeCell<T>>,
diff --git a/tests/expectations/tests/size_t_template.rs b/tests/expectations/tests/size_t_template.rs
index 937a8c72..47e75edb 100644
--- a/tests/expectations/tests/size_t_template.rs
+++ b/tests/expectations/tests/size_t_template.rs
@@ -23,3 +23,12 @@ fn bindgen_test_layout_C() {
impl Default for C {
fn default() -> Self { unsafe { ::std::mem::zeroed() } }
}
+#[test]
+fn __bindgen_test_layout_Array_instantiation() {
+ assert_eq!(::std::mem::size_of::<[u32; 3usize]>() , 12usize , concat ! (
+ "Size of template specialization: " , stringify ! (
+ [u32; 3usize] ) ));
+ assert_eq!(::std::mem::align_of::<[u32; 3usize]>() , 4usize , concat ! (
+ "Alignment of template specialization: " , stringify ! (
+ [u32; 3usize] ) ));
+}
diff --git a/tests/expectations/tests/struct_with_bitfields.rs b/tests/expectations/tests/struct_with_bitfields.rs
index 44681d2e..b93b441f 100644
--- a/tests/expectations/tests/struct_with_bitfields.rs
+++ b/tests/expectations/tests/struct_with_bitfields.rs
@@ -29,75 +29,147 @@ impl Clone for bitfield {
impl bitfield {
#[inline]
pub fn a(&self) -> ::std::os::raw::c_ushort {
- let mask = 1usize as u8;
- let unit_field_val: u8 =
- unsafe { ::std::mem::transmute(self._bitfield_1) };
+ let mut unit_field_val: u8 = unsafe { ::std::mem::uninitialized() };
+ unsafe {
+ ::std::ptr::copy_nonoverlapping(&self._bitfield_1 as *const _ as
+ *const u8,
+ &mut unit_field_val as *mut u8 as
+ *mut u8,
+ ::std::mem::size_of::<u8>())
+ };
+ let mask = 1u64 as u8;
let val = (unit_field_val & mask) >> 0usize;
unsafe { ::std::mem::transmute(val as u16) }
}
#[inline]
pub fn set_a(&mut self, val: ::std::os::raw::c_ushort) {
- let mask = 1usize as u8;
+ let mask = 1u64 as u8;
let val = val as u16 as u8;
- let mut unit_field_val: u8 =
- unsafe { ::std::mem::transmute(self._bitfield_1) };
+ let mut unit_field_val: u8 = unsafe { ::std::mem::uninitialized() };
+ unsafe {
+ ::std::ptr::copy_nonoverlapping(&self._bitfield_1 as *const _ as
+ *const u8,
+ &mut unit_field_val as *mut u8 as
+ *mut u8,
+ ::std::mem::size_of::<u8>())
+ };
unit_field_val &= !mask;
unit_field_val |= (val << 0usize) & mask;
- self._bitfield_1 = unsafe { ::std::mem::transmute(unit_field_val) };
+ unsafe {
+ ::std::ptr::copy_nonoverlapping(&unit_field_val as *const _ as
+ *const u8,
+ &mut self._bitfield_1 as *mut _ as
+ *mut u8,
+ ::std::mem::size_of::<u8>());
+ }
}
#[inline]
pub fn b(&self) -> ::std::os::raw::c_ushort {
- let mask = 2usize as u8;
- let unit_field_val: u8 =
- unsafe { ::std::mem::transmute(self._bitfield_1) };
+ let mut unit_field_val: u8 = unsafe { ::std::mem::uninitialized() };
+ unsafe {
+ ::std::ptr::copy_nonoverlapping(&self._bitfield_1 as *const _ as
+ *const u8,
+ &mut unit_field_val as *mut u8 as
+ *mut u8,
+ ::std::mem::size_of::<u8>())
+ };
+ let mask = 2u64 as u8;
let val = (unit_field_val & mask) >> 1usize;
unsafe { ::std::mem::transmute(val as u16) }
}
#[inline]
pub fn set_b(&mut self, val: ::std::os::raw::c_ushort) {
- let mask = 2usize as u8;
+ let mask = 2u64 as u8;
let val = val as u16 as u8;
- let mut unit_field_val: u8 =
- unsafe { ::std::mem::transmute(self._bitfield_1) };
+ let mut unit_field_val: u8 = unsafe { ::std::mem::uninitialized() };
+ unsafe {
+ ::std::ptr::copy_nonoverlapping(&self._bitfield_1 as *const _ as
+ *const u8,
+ &mut unit_field_val as *mut u8 as
+ *mut u8,
+ ::std::mem::size_of::<u8>())
+ };
unit_field_val &= !mask;
unit_field_val |= (val << 1usize) & mask;
- self._bitfield_1 = unsafe { ::std::mem::transmute(unit_field_val) };
+ unsafe {
+ ::std::ptr::copy_nonoverlapping(&unit_field_val as *const _ as
+ *const u8,
+ &mut self._bitfield_1 as *mut _ as
+ *mut u8,
+ ::std::mem::size_of::<u8>());
+ }
}
#[inline]
pub fn c(&self) -> ::std::os::raw::c_ushort {
- let mask = 4usize as u8;
- let unit_field_val: u8 =
- unsafe { ::std::mem::transmute(self._bitfield_1) };
+ let mut unit_field_val: u8 = unsafe { ::std::mem::uninitialized() };
+ unsafe {
+ ::std::ptr::copy_nonoverlapping(&self._bitfield_1 as *const _ as
+ *const u8,
+ &mut unit_field_val as *mut u8 as
+ *mut u8,
+ ::std::mem::size_of::<u8>())
+ };
+ let mask = 4u64 as u8;
let val = (unit_field_val & mask) >> 2usize;
unsafe { ::std::mem::transmute(val as u16) }
}
#[inline]
pub fn set_c(&mut self, val: ::std::os::raw::c_ushort) {
- let mask = 4usize as u8;
+ let mask = 4u64 as u8;
let val = val as u16 as u8;
- let mut unit_field_val: u8 =
- unsafe { ::std::mem::transmute(self._bitfield_1) };
+ let mut unit_field_val: u8 = unsafe { ::std::mem::uninitialized() };
+ unsafe {
+ ::std::ptr::copy_nonoverlapping(&self._bitfield_1 as *const _ as
+ *const u8,
+ &mut unit_field_val as *mut u8 as
+ *mut u8,
+ ::std::mem::size_of::<u8>())
+ };
unit_field_val &= !mask;
unit_field_val |= (val << 2usize) & mask;
- self._bitfield_1 = unsafe { ::std::mem::transmute(unit_field_val) };
+ unsafe {
+ ::std::ptr::copy_nonoverlapping(&unit_field_val as *const _ as
+ *const u8,
+ &mut self._bitfield_1 as *mut _ as
+ *mut u8,
+ ::std::mem::size_of::<u8>());
+ }
}
#[inline]
pub fn d(&self) -> ::std::os::raw::c_ushort {
- let mask = 192usize as u8;
- let unit_field_val: u8 =
- unsafe { ::std::mem::transmute(self._bitfield_1) };
+ let mut unit_field_val: u8 = unsafe { ::std::mem::uninitialized() };
+ unsafe {
+ ::std::ptr::copy_nonoverlapping(&self._bitfield_1 as *const _ as
+ *const u8,
+ &mut unit_field_val as *mut u8 as
+ *mut u8,
+ ::std::mem::size_of::<u8>())
+ };
+ let mask = 192u64 as u8;
let val = (unit_field_val & mask) >> 6usize;
unsafe { ::std::mem::transmute(val as u16) }
}
#[inline]
pub fn set_d(&mut self, val: ::std::os::raw::c_ushort) {
- let mask = 192usize as u8;
+ let mask = 192u64 as u8;
let val = val as u16 as u8;
- let mut unit_field_val: u8 =
- unsafe { ::std::mem::transmute(self._bitfield_1) };
+ let mut unit_field_val: u8 = unsafe { ::std::mem::uninitialized() };
+ unsafe {
+ ::std::ptr::copy_nonoverlapping(&self._bitfield_1 as *const _ as
+ *const u8,
+ &mut unit_field_val as *mut u8 as
+ *mut u8,
+ ::std::mem::size_of::<u8>())
+ };
unit_field_val &= !mask;
unit_field_val |= (val << 6usize) & mask;
- self._bitfield_1 = unsafe { ::std::mem::transmute(unit_field_val) };
+ unsafe {
+ ::std::ptr::copy_nonoverlapping(&unit_field_val as *const _ as
+ *const u8,
+ &mut self._bitfield_1 as *mut _ as
+ *mut u8,
+ ::std::mem::size_of::<u8>());
+ }
}
#[inline]
pub fn new_bitfield_1(a: ::std::os::raw::c_ushort,
@@ -106,52 +178,88 @@ impl bitfield {
d: ::std::os::raw::c_ushort) -> u8 {
({
({
- ({ ({ 0 } | ((a as u16 as u8) << 0usize) & (1usize as u8)) }
- | ((b as u16 as u8) << 1usize) & (2usize as u8))
- } | ((c as u16 as u8) << 2usize) & (4usize as u8))
- } | ((d as u16 as u8) << 6usize) & (192usize as u8))
+ ({ ({ 0 } | ((a as u16 as u8) << 0usize) & (1u64 as u8)) } |
+ ((b as u16 as u8) << 1usize) & (2u64 as u8))
+ } | ((c as u16 as u8) << 2usize) & (4u64 as u8))
+ } | ((d as u16 as u8) << 6usize) & (192u64 as u8))
}
#[inline]
pub fn f(&self) -> ::std::os::raw::c_uint {
- let mask = 3usize as u64;
- let unit_field_val: u64 =
- unsafe { ::std::mem::transmute(self._bitfield_2) };
+ let mut unit_field_val: u64 = unsafe { ::std::mem::uninitialized() };
+ unsafe {
+ ::std::ptr::copy_nonoverlapping(&self._bitfield_2 as *const _ as
+ *const u8,
+ &mut unit_field_val as *mut u64 as
+ *mut u8,
+ ::std::mem::size_of::<u64>())
+ };
+ let mask = 3u64 as u64;
let val = (unit_field_val & mask) >> 0usize;
unsafe { ::std::mem::transmute(val as u32) }
}
#[inline]
pub fn set_f(&mut self, val: ::std::os::raw::c_uint) {
- let mask = 3usize as u64;
+ let mask = 3u64 as u64;
let val = val as u32 as u64;
- let mut unit_field_val: u64 =
- unsafe { ::std::mem::transmute(self._bitfield_2) };
+ let mut unit_field_val: u64 = unsafe { ::std::mem::uninitialized() };
+ unsafe {
+ ::std::ptr::copy_nonoverlapping(&self._bitfield_2 as *const _ as
+ *const u8,
+ &mut unit_field_val as *mut u64 as
+ *mut u8,
+ ::std::mem::size_of::<u64>())
+ };
unit_field_val &= !mask;
unit_field_val |= (val << 0usize) & mask;
- self._bitfield_2 = unsafe { ::std::mem::transmute(unit_field_val) };
+ unsafe {
+ ::std::ptr::copy_nonoverlapping(&unit_field_val as *const _ as
+ *const u8,
+ &mut self._bitfield_2 as *mut _ as
+ *mut u8,
+ ::std::mem::size_of::<u64>());
+ }
}
#[inline]
pub fn g(&self) -> ::std::os::raw::c_uint {
- let mask = 18446744069414584320usize as u64;
- let unit_field_val: u64 =
- unsafe { ::std::mem::transmute(self._bitfield_2) };
+ let mut unit_field_val: u64 = unsafe { ::std::mem::uninitialized() };
+ unsafe {
+ ::std::ptr::copy_nonoverlapping(&self._bitfield_2 as *const _ as
+ *const u8,
+ &mut unit_field_val as *mut u64 as
+ *mut u8,
+ ::std::mem::size_of::<u64>())
+ };
+ let mask = 18446744069414584320u64 as u64;
let val = (unit_field_val & mask) >> 32usize;
unsafe { ::std::mem::transmute(val as u32) }
}
#[inline]
pub fn set_g(&mut self, val: ::std::os::raw::c_uint) {
- let mask = 18446744069414584320usize as u64;
+ let mask = 18446744069414584320u64 as u64;
let val = val as u32 as u64;
- let mut unit_field_val: u64 =
- unsafe { ::std::mem::transmute(self._bitfield_2) };
+ let mut unit_field_val: u64 = unsafe { ::std::mem::uninitialized() };
+ unsafe {
+ ::std::ptr::copy_nonoverlapping(&self._bitfield_2 as *const _ as
+ *const u8,
+ &mut unit_field_val as *mut u64 as
+ *mut u8,
+ ::std::mem::size_of::<u64>())
+ };
unit_field_val &= !mask;
unit_field_val |= (val << 32usize) & mask;
- self._bitfield_2 = unsafe { ::std::mem::transmute(unit_field_val) };
+ unsafe {
+ ::std::ptr::copy_nonoverlapping(&unit_field_val as *const _ as
+ *const u8,
+ &mut self._bitfield_2 as *mut _ as
+ *mut u8,
+ ::std::mem::size_of::<u64>());
+ }
}
#[inline]
pub fn new_bitfield_2(f: ::std::os::raw::c_uint,
g: ::std::os::raw::c_uint) -> u64 {
- ({ ({ 0 } | ((f as u32 as u64) << 0usize) & (3usize as u64)) } |
+ ({ ({ 0 } | ((f as u32 as u64) << 0usize) & (3u64 as u64)) } |
((g as u32 as u64) << 32usize) &
- (18446744069414584320usize as u64))
+ (18446744069414584320u64 as u64))
}
}
diff --git a/tests/expectations/tests/template-with-var.rs b/tests/expectations/tests/template-with-var.rs
new file mode 100644
index 00000000..0b0a8cb6
--- /dev/null
+++ b/tests/expectations/tests/template-with-var.rs
@@ -0,0 +1,11 @@
+/* automatically generated by rust-bindgen */
+
+
+#![allow(dead_code, non_snake_case, non_camel_case_types, non_upper_case_globals)]
+
+
+#[repr(C)]
+#[derive(Debug, Default, Copy, Clone)]
+pub struct TemplateWithVar {
+ pub _address: u8,
+}
diff --git a/tests/expectations/tests/template.rs b/tests/expectations/tests/template.rs
index 5eed8c47..e666ee38 100644
--- a/tests/expectations/tests/template.rs
+++ b/tests/expectations/tests/template.rs
@@ -239,13 +239,8 @@ pub struct ReplacedWithoutDestructorFwd<T> {
impl <T> Default for ReplacedWithoutDestructorFwd<T> {
fn default() -> Self { unsafe { ::std::mem::zeroed() } }
}
-#[repr(C)]
-#[derive(Debug, Default, Copy, Clone)]
-pub struct TemplateWithVar {
- pub _address: u8,
-}
#[test]
-fn __bindgen_test_layout_Foo_instantiation_1() {
+fn __bindgen_test_layout_Foo_instantiation() {
assert_eq!(::std::mem::size_of::<Foo<::std::os::raw::c_int>>() , 24usize ,
concat ! (
"Size of template specialization: " , stringify ! (
@@ -256,7 +251,7 @@ fn __bindgen_test_layout_Foo_instantiation_1() {
Foo<::std::os::raw::c_int> ) ));
}
#[test]
-fn __bindgen_test_layout_Foo_instantiation_2() {
+fn __bindgen_test_layout_Foo_instantiation_1() {
assert_eq!(::std::mem::size_of::<Foo<::std::os::raw::c_int>>() , 24usize ,
concat ! (
"Size of template specialization: " , stringify ! (
@@ -267,7 +262,18 @@ fn __bindgen_test_layout_Foo_instantiation_2() {
Foo<::std::os::raw::c_int> ) ));
}
#[test]
-fn __bindgen_test_layout_Rooted_instantiation_3() {
+fn __bindgen_test_layout_Rooted_instantiation() {
+ assert_eq!(::std::mem::size_of::<Rooted<*mut ::std::os::raw::c_void>>() ,
+ 24usize , concat ! (
+ "Size of template specialization: " , stringify ! (
+ Rooted<*mut ::std::os::raw::c_void> ) ));
+ assert_eq!(::std::mem::align_of::<Rooted<*mut ::std::os::raw::c_void>>() ,
+ 8usize , concat ! (
+ "Alignment of template specialization: " , stringify ! (
+ Rooted<*mut ::std::os::raw::c_void> ) ));
+}
+#[test]
+fn __bindgen_test_layout_Rooted_instantiation_1() {
assert_eq!(::std::mem::size_of::<Rooted<*mut ::std::os::raw::c_void>>() ,
24usize , concat ! (
"Size of template specialization: " , stringify ! (
@@ -278,7 +284,7 @@ fn __bindgen_test_layout_Rooted_instantiation_3() {
Rooted<*mut ::std::os::raw::c_void> ) ));
}
#[test]
-fn __bindgen_test_layout_WithDtor_instantiation_4() {
+fn __bindgen_test_layout_WithDtor_instantiation() {
assert_eq!(::std::mem::size_of::<WithDtor<::std::os::raw::c_int>>() ,
4usize , concat ! (
"Size of template specialization: " , stringify ! (
@@ -288,3 +294,11 @@ fn __bindgen_test_layout_WithDtor_instantiation_4() {
"Alignment of template specialization: " , stringify ! (
WithDtor<::std::os::raw::c_int> ) ));
}
+#[test]
+fn __bindgen_test_layout_Opaque_instantiation() {
+ assert_eq!(::std::mem::size_of::<u32>() , 4usize , concat ! (
+ "Size of template specialization: " , stringify ! ( u32 ) ));
+ assert_eq!(::std::mem::align_of::<u32>() , 4usize , concat ! (
+ "Alignment of template specialization: " , stringify ! ( u32 )
+ ));
+}
diff --git a/tests/expectations/tests/typeref.rs b/tests/expectations/tests/typeref.rs
index b5be5557..b3b75594 100644
--- a/tests/expectations/tests/typeref.rs
+++ b/tests/expectations/tests/typeref.rs
@@ -123,3 +123,14 @@ impl Clone for Bar {
impl Default for Bar {
fn default() -> Self { unsafe { ::std::mem::zeroed() } }
}
+#[test]
+fn __bindgen_test_layout_mozilla_StyleShapeSource_instantiation() {
+ assert_eq!(::std::mem::size_of::<mozilla_StyleShapeSource>() , 8usize ,
+ concat ! (
+ "Size of template specialization: " , stringify ! (
+ mozilla_StyleShapeSource ) ));
+ assert_eq!(::std::mem::align_of::<mozilla_StyleShapeSource>() , 8usize ,
+ concat ! (
+ "Alignment of template specialization: " , stringify ! (
+ mozilla_StyleShapeSource ) ));
+}
diff --git a/tests/expectations/tests/union_with_anon_struct_bitfield.rs b/tests/expectations/tests/union_with_anon_struct_bitfield.rs
index cf3ab206..e6acd105 100644
--- a/tests/expectations/tests/union_with_anon_struct_bitfield.rs
+++ b/tests/expectations/tests/union_with_anon_struct_bitfield.rs
@@ -54,45 +54,81 @@ impl Clone for foo__bindgen_ty_1 {
impl foo__bindgen_ty_1 {
#[inline]
pub fn b(&self) -> ::std::os::raw::c_int {
- let mask = 127usize as u32;
- let unit_field_val: u32 =
- unsafe { ::std::mem::transmute(self._bitfield_1) };
+ let mut unit_field_val: u32 = unsafe { ::std::mem::uninitialized() };
+ unsafe {
+ ::std::ptr::copy_nonoverlapping(&self._bitfield_1 as *const _ as
+ *const u8,
+ &mut unit_field_val as *mut u32 as
+ *mut u8,
+ ::std::mem::size_of::<u32>())
+ };
+ let mask = 127u64 as u32;
let val = (unit_field_val & mask) >> 0usize;
unsafe { ::std::mem::transmute(val as u32) }
}
#[inline]
pub fn set_b(&mut self, val: ::std::os::raw::c_int) {
- let mask = 127usize as u32;
+ let mask = 127u64 as u32;
let val = val as u32 as u32;
- let mut unit_field_val: u32 =
- unsafe { ::std::mem::transmute(self._bitfield_1) };
+ let mut unit_field_val: u32 = unsafe { ::std::mem::uninitialized() };
+ unsafe {
+ ::std::ptr::copy_nonoverlapping(&self._bitfield_1 as *const _ as
+ *const u8,
+ &mut unit_field_val as *mut u32 as
+ *mut u8,
+ ::std::mem::size_of::<u32>())
+ };
unit_field_val &= !mask;
unit_field_val |= (val << 0usize) & mask;
- self._bitfield_1 = unsafe { ::std::mem::transmute(unit_field_val) };
+ unsafe {
+ ::std::ptr::copy_nonoverlapping(&unit_field_val as *const _ as
+ *const u8,
+ &mut self._bitfield_1 as *mut _ as
+ *mut u8,
+ ::std::mem::size_of::<u32>());
+ }
}
#[inline]
pub fn c(&self) -> ::std::os::raw::c_int {
- let mask = 4294967168usize as u32;
- let unit_field_val: u32 =
- unsafe { ::std::mem::transmute(self._bitfield_1) };
+ let mut unit_field_val: u32 = unsafe { ::std::mem::uninitialized() };
+ unsafe {
+ ::std::ptr::copy_nonoverlapping(&self._bitfield_1 as *const _ as
+ *const u8,
+ &mut unit_field_val as *mut u32 as
+ *mut u8,
+ ::std::mem::size_of::<u32>())
+ };
+ let mask = 4294967168u64 as u32;
let val = (unit_field_val & mask) >> 7usize;
unsafe { ::std::mem::transmute(val as u32) }
}
#[inline]
pub fn set_c(&mut self, val: ::std::os::raw::c_int) {
- let mask = 4294967168usize as u32;
+ let mask = 4294967168u64 as u32;
let val = val as u32 as u32;
- let mut unit_field_val: u32 =
- unsafe { ::std::mem::transmute(self._bitfield_1) };
+ let mut unit_field_val: u32 = unsafe { ::std::mem::uninitialized() };
+ unsafe {
+ ::std::ptr::copy_nonoverlapping(&self._bitfield_1 as *const _ as
+ *const u8,
+ &mut unit_field_val as *mut u32 as
+ *mut u8,
+ ::std::mem::size_of::<u32>())
+ };
unit_field_val &= !mask;
unit_field_val |= (val << 7usize) & mask;
- self._bitfield_1 = unsafe { ::std::mem::transmute(unit_field_val) };
+ unsafe {
+ ::std::ptr::copy_nonoverlapping(&unit_field_val as *const _ as
+ *const u8,
+ &mut self._bitfield_1 as *mut _ as
+ *mut u8,
+ ::std::mem::size_of::<u32>());
+ }
}
#[inline]
pub fn new_bitfield_1(b: ::std::os::raw::c_int, c: ::std::os::raw::c_int)
-> u32 {
- ({ ({ 0 } | ((b as u32 as u32) << 0usize) & (127usize as u32)) } |
- ((c as u32 as u32) << 7usize) & (4294967168usize as u32))
+ ({ ({ 0 } | ((b as u32 as u32) << 0usize) & (127u64 as u32)) } |
+ ((c as u32 as u32) << 7usize) & (4294967168u64 as u32))
}
}
#[test]
diff --git a/tests/expectations/tests/virtual_dtor.rs b/tests/expectations/tests/virtual_dtor.rs
index 9a6ee13e..8d6d9dcd 100644
--- a/tests/expectations/tests/virtual_dtor.rs
+++ b/tests/expectations/tests/virtual_dtor.rs
@@ -21,3 +21,7 @@ fn bindgen_test_layout_nsSlots() {
impl Default for nsSlots {
fn default() -> Self { unsafe { ::std::mem::zeroed() } }
}
+extern "C" {
+ #[link_name = "_ZN7nsSlotsD0Ev"]
+ pub fn nsSlots_nsSlots_destructor(this: *mut nsSlots);
+}
diff --git a/tests/expectations/tests/virtual_overloaded.rs b/tests/expectations/tests/virtual_overloaded.rs
index a0489685..90f9d928 100644
--- a/tests/expectations/tests/virtual_overloaded.rs
+++ b/tests/expectations/tests/virtual_overloaded.rs
@@ -24,3 +24,13 @@ impl Clone for C {
impl Default for C {
fn default() -> Self { unsafe { ::std::mem::zeroed() } }
}
+extern "C" {
+ #[link_name = "_ZN1C8do_thingEc"]
+ pub fn C_do_thing(this: *mut ::std::os::raw::c_void,
+ arg1: ::std::os::raw::c_char);
+}
+extern "C" {
+ #[link_name = "_ZN1C8do_thingEi"]
+ pub fn C_do_thing1(this: *mut ::std::os::raw::c_void,
+ arg1: ::std::os::raw::c_int);
+}
diff --git a/tests/expectations/tests/vtable_recursive_sig.rs b/tests/expectations/tests/vtable_recursive_sig.rs
index 9a8b5be6..f112e0cc 100644
--- a/tests/expectations/tests/vtable_recursive_sig.rs
+++ b/tests/expectations/tests/vtable_recursive_sig.rs
@@ -42,3 +42,7 @@ impl Clone for Base {
impl Default for Base {
fn default() -> Self { unsafe { ::std::mem::zeroed() } }
}
+extern "C" {
+ #[link_name = "_ZN4Base9AsDerivedEv"]
+ pub fn Base_AsDerived(this: *mut ::std::os::raw::c_void) -> *mut Derived;
+}
diff --git a/tests/expectations/tests/weird_bitfields.rs b/tests/expectations/tests/weird_bitfields.rs
index 2fb9cbc5..0b97c368 100644
--- a/tests/expectations/tests/weird_bitfields.rs
+++ b/tests/expectations/tests/weird_bitfields.rs
@@ -106,137 +106,261 @@ impl Default for Weird {
impl Weird {
#[inline]
pub fn bitTest(&self) -> ::std::os::raw::c_uint {
- let mask = 65535usize as u32;
- let unit_field_val: u32 =
- unsafe { ::std::mem::transmute(self._bitfield_1) };
+ let mut unit_field_val: u32 = unsafe { ::std::mem::uninitialized() };
+ unsafe {
+ ::std::ptr::copy_nonoverlapping(&self._bitfield_1 as *const _ as
+ *const u8,
+ &mut unit_field_val as *mut u32 as
+ *mut u8,
+ ::std::mem::size_of::<u32>())
+ };
+ let mask = 65535u64 as u32;
let val = (unit_field_val & mask) >> 0usize;
unsafe { ::std::mem::transmute(val as u32) }
}
#[inline]
pub fn set_bitTest(&mut self, val: ::std::os::raw::c_uint) {
- let mask = 65535usize as u32;
+ let mask = 65535u64 as u32;
let val = val as u32 as u32;
- let mut unit_field_val: u32 =
- unsafe { ::std::mem::transmute(self._bitfield_1) };
+ let mut unit_field_val: u32 = unsafe { ::std::mem::uninitialized() };
+ unsafe {
+ ::std::ptr::copy_nonoverlapping(&self._bitfield_1 as *const _ as
+ *const u8,
+ &mut unit_field_val as *mut u32 as
+ *mut u8,
+ ::std::mem::size_of::<u32>())
+ };
unit_field_val &= !mask;
unit_field_val |= (val << 0usize) & mask;
- self._bitfield_1 = unsafe { ::std::mem::transmute(unit_field_val) };
+ unsafe {
+ ::std::ptr::copy_nonoverlapping(&unit_field_val as *const _ as
+ *const u8,
+ &mut self._bitfield_1 as *mut _ as
+ *mut u8,
+ ::std::mem::size_of::<u32>());
+ }
}
#[inline]
pub fn bitTest2(&self) -> ::std::os::raw::c_uint {
- let mask = 2147418112usize as u32;
- let unit_field_val: u32 =
- unsafe { ::std::mem::transmute(self._bitfield_1) };
+ let mut unit_field_val: u32 = unsafe { ::std::mem::uninitialized() };
+ unsafe {
+ ::std::ptr::copy_nonoverlapping(&self._bitfield_1 as *const _ as
+ *const u8,
+ &mut unit_field_val as *mut u32 as
+ *mut u8,
+ ::std::mem::size_of::<u32>())
+ };
+ let mask = 2147418112u64 as u32;
let val = (unit_field_val & mask) >> 16usize;
unsafe { ::std::mem::transmute(val as u32) }
}
#[inline]
pub fn set_bitTest2(&mut self, val: ::std::os::raw::c_uint) {
- let mask = 2147418112usize as u32;
+ let mask = 2147418112u64 as u32;
let val = val as u32 as u32;
- let mut unit_field_val: u32 =
- unsafe { ::std::mem::transmute(self._bitfield_1) };
+ let mut unit_field_val: u32 = unsafe { ::std::mem::uninitialized() };
+ unsafe {
+ ::std::ptr::copy_nonoverlapping(&self._bitfield_1 as *const _ as
+ *const u8,
+ &mut unit_field_val as *mut u32 as
+ *mut u8,
+ ::std::mem::size_of::<u32>())
+ };
unit_field_val &= !mask;
unit_field_val |= (val << 16usize) & mask;
- self._bitfield_1 = unsafe { ::std::mem::transmute(unit_field_val) };
+ unsafe {
+ ::std::ptr::copy_nonoverlapping(&unit_field_val as *const _ as
+ *const u8,
+ &mut self._bitfield_1 as *mut _ as
+ *mut u8,
+ ::std::mem::size_of::<u32>());
+ }
}
#[inline]
pub fn new_bitfield_1(bitTest: ::std::os::raw::c_uint,
bitTest2: ::std::os::raw::c_uint) -> u32 {
- ({
- ({ 0 } |
- ((bitTest as u32 as u32) << 0usize) & (65535usize as u32))
- } | ((bitTest2 as u32 as u32) << 16usize) & (2147418112usize as u32))
+ ({ ({ 0 } | ((bitTest as u32 as u32) << 0usize) & (65535u64 as u32)) }
+ | ((bitTest2 as u32 as u32) << 16usize) & (2147418112u64 as u32))
}
#[inline]
pub fn mFillOpacitySource(&self) -> nsStyleSVGOpacitySource {
- let mask = 7usize as u16;
- let unit_field_val: u16 =
- unsafe { ::std::mem::transmute(self._bitfield_2) };
+ let mut unit_field_val: u16 = unsafe { ::std::mem::uninitialized() };
+ unsafe {
+ ::std::ptr::copy_nonoverlapping(&self._bitfield_2 as *const _ as
+ *const u8,
+ &mut unit_field_val as *mut u16 as
+ *mut u8,
+ ::std::mem::size_of::<u16>())
+ };
+ let mask = 7u64 as u16;
let val = (unit_field_val & mask) >> 0usize;
unsafe { ::std::mem::transmute(val as u32) }
}
#[inline]
pub fn set_mFillOpacitySource(&mut self, val: nsStyleSVGOpacitySource) {
- let mask = 7usize as u16;
+ let mask = 7u64 as u16;
let val = val as u32 as u16;
- let mut unit_field_val: u16 =
- unsafe { ::std::mem::transmute(self._bitfield_2) };
+ let mut unit_field_val: u16 = unsafe { ::std::mem::uninitialized() };
+ unsafe {
+ ::std::ptr::copy_nonoverlapping(&self._bitfield_2 as *const _ as
+ *const u8,
+ &mut unit_field_val as *mut u16 as
+ *mut u8,
+ ::std::mem::size_of::<u16>())
+ };
unit_field_val &= !mask;
unit_field_val |= (val << 0usize) & mask;
- self._bitfield_2 = unsafe { ::std::mem::transmute(unit_field_val) };
+ unsafe {
+ ::std::ptr::copy_nonoverlapping(&unit_field_val as *const _ as
+ *const u8,
+ &mut self._bitfield_2 as *mut _ as
+ *mut u8,
+ ::std::mem::size_of::<u16>());
+ }
}
#[inline]
pub fn mStrokeOpacitySource(&self) -> nsStyleSVGOpacitySource {
- let mask = 56usize as u16;
- let unit_field_val: u16 =
- unsafe { ::std::mem::transmute(self._bitfield_2) };
+ let mut unit_field_val: u16 = unsafe { ::std::mem::uninitialized() };
+ unsafe {
+ ::std::ptr::copy_nonoverlapping(&self._bitfield_2 as *const _ as
+ *const u8,
+ &mut unit_field_val as *mut u16 as
+ *mut u8,
+ ::std::mem::size_of::<u16>())
+ };
+ let mask = 56u64 as u16;
let val = (unit_field_val & mask) >> 3usize;
unsafe { ::std::mem::transmute(val as u32) }
}
#[inline]
pub fn set_mStrokeOpacitySource(&mut self, val: nsStyleSVGOpacitySource) {
- let mask = 56usize as u16;
+ let mask = 56u64 as u16;
let val = val as u32 as u16;
- let mut unit_field_val: u16 =
- unsafe { ::std::mem::transmute(self._bitfield_2) };
+ let mut unit_field_val: u16 = unsafe { ::std::mem::uninitialized() };
+ unsafe {
+ ::std::ptr::copy_nonoverlapping(&self._bitfield_2 as *const _ as
+ *const u8,
+ &mut unit_field_val as *mut u16 as
+ *mut u8,
+ ::std::mem::size_of::<u16>())
+ };
unit_field_val &= !mask;
unit_field_val |= (val << 3usize) & mask;
- self._bitfield_2 = unsafe { ::std::mem::transmute(unit_field_val) };
+ unsafe {
+ ::std::ptr::copy_nonoverlapping(&unit_field_val as *const _ as
+ *const u8,
+ &mut self._bitfield_2 as *mut _ as
+ *mut u8,
+ ::std::mem::size_of::<u16>());
+ }
}
#[inline]
pub fn mStrokeDasharrayFromObject(&self) -> bool {
- let mask = 64usize as u16;
- let unit_field_val: u16 =
- unsafe { ::std::mem::transmute(self._bitfield_2) };
+ let mut unit_field_val: u16 = unsafe { ::std::mem::uninitialized() };
+ unsafe {
+ ::std::ptr::copy_nonoverlapping(&self._bitfield_2 as *const _ as
+ *const u8,
+ &mut unit_field_val as *mut u16 as
+ *mut u8,
+ ::std::mem::size_of::<u16>())
+ };
+ let mask = 64u64 as u16;
let val = (unit_field_val & mask) >> 6usize;
unsafe { ::std::mem::transmute(val as u8) }
}
#[inline]
pub fn set_mStrokeDasharrayFromObject(&mut self, val: bool) {
- let mask = 64usize as u16;
+ let mask = 64u64 as u16;
let val = val as u8 as u16;
- let mut unit_field_val: u16 =
- unsafe { ::std::mem::transmute(self._bitfield_2) };
+ let mut unit_field_val: u16 = unsafe { ::std::mem::uninitialized() };
+ unsafe {
+ ::std::ptr::copy_nonoverlapping(&self._bitfield_2 as *const _ as
+ *const u8,
+ &mut unit_field_val as *mut u16 as
+ *mut u8,
+ ::std::mem::size_of::<u16>())
+ };
unit_field_val &= !mask;
unit_field_val |= (val << 6usize) & mask;
- self._bitfield_2 = unsafe { ::std::mem::transmute(unit_field_val) };
+ unsafe {
+ ::std::ptr::copy_nonoverlapping(&unit_field_val as *const _ as
+ *const u8,
+ &mut self._bitfield_2 as *mut _ as
+ *mut u8,
+ ::std::mem::size_of::<u16>());
+ }
}
#[inline]
pub fn mStrokeDashoffsetFromObject(&self) -> bool {
- let mask = 128usize as u16;
- let unit_field_val: u16 =
- unsafe { ::std::mem::transmute(self._bitfield_2) };
+ let mut unit_field_val: u16 = unsafe { ::std::mem::uninitialized() };
+ unsafe {
+ ::std::ptr::copy_nonoverlapping(&self._bitfield_2 as *const _ as
+ *const u8,
+ &mut unit_field_val as *mut u16 as
+ *mut u8,
+ ::std::mem::size_of::<u16>())
+ };
+ let mask = 128u64 as u16;
let val = (unit_field_val & mask) >> 7usize;
unsafe { ::std::mem::transmute(val as u8) }
}
#[inline]
pub fn set_mStrokeDashoffsetFromObject(&mut self, val: bool) {
- let mask = 128usize as u16;
+ let mask = 128u64 as u16;
let val = val as u8 as u16;
- let mut unit_field_val: u16 =
- unsafe { ::std::mem::transmute(self._bitfield_2) };
+ let mut unit_field_val: u16 = unsafe { ::std::mem::uninitialized() };
+ unsafe {
+ ::std::ptr::copy_nonoverlapping(&self._bitfield_2 as *const _ as
+ *const u8,
+ &mut unit_field_val as *mut u16 as
+ *mut u8,
+ ::std::mem::size_of::<u16>())
+ };
unit_field_val &= !mask;
unit_field_val |= (val << 7usize) & mask;
- self._bitfield_2 = unsafe { ::std::mem::transmute(unit_field_val) };
+ unsafe {
+ ::std::ptr::copy_nonoverlapping(&unit_field_val as *const _ as
+ *const u8,
+ &mut self._bitfield_2 as *mut _ as
+ *mut u8,
+ ::std::mem::size_of::<u16>());
+ }
}
#[inline]
pub fn mStrokeWidthFromObject(&self) -> bool {
- let mask = 256usize as u16;
- let unit_field_val: u16 =
- unsafe { ::std::mem::transmute(self._bitfield_2) };
+ let mut unit_field_val: u16 = unsafe { ::std::mem::uninitialized() };
+ unsafe {
+ ::std::ptr::copy_nonoverlapping(&self._bitfield_2 as *const _ as
+ *const u8,
+ &mut unit_field_val as *mut u16 as
+ *mut u8,
+ ::std::mem::size_of::<u16>())
+ };
+ let mask = 256u64 as u16;
let val = (unit_field_val & mask) >> 8usize;
unsafe { ::std::mem::transmute(val as u8) }
}
#[inline]
pub fn set_mStrokeWidthFromObject(&mut self, val: bool) {
- let mask = 256usize as u16;
+ let mask = 256u64 as u16;
let val = val as u8 as u16;
- let mut unit_field_val: u16 =
- unsafe { ::std::mem::transmute(self._bitfield_2) };
+ let mut unit_field_val: u16 = unsafe { ::std::mem::uninitialized() };
+ unsafe {
+ ::std::ptr::copy_nonoverlapping(&self._bitfield_2 as *const _ as
+ *const u8,
+ &mut unit_field_val as *mut u16 as
+ *mut u8,
+ ::std::mem::size_of::<u16>())
+ };
unit_field_val &= !mask;
unit_field_val |= (val << 8usize) & mask;
- self._bitfield_2 = unsafe { ::std::mem::transmute(unit_field_val) };
+ unsafe {
+ ::std::ptr::copy_nonoverlapping(&unit_field_val as *const _ as
+ *const u8,
+ &mut self._bitfield_2 as *mut _ as
+ *mut u8,
+ ::std::mem::size_of::<u16>());
+ }
}
#[inline]
pub fn new_bitfield_2(mFillOpacitySource: nsStyleSVGOpacitySource,
@@ -250,18 +374,18 @@ impl Weird {
({
({ 0 } |
((mFillOpacitySource as u32 as u16) <<
- 0usize) & (7usize as u16))
+ 0usize) & (7u64 as u16))
} |
((mStrokeOpacitySource as u32 as u16) << 3usize) &
- (56usize as u16))
+ (56u64 as u16))
} |
((mStrokeDasharrayFromObject as u8 as u16) << 6usize) &
- (64usize as u16))
+ (64u64 as u16))
} |
((mStrokeDashoffsetFromObject as u8 as u16) << 7usize) &
- (128usize as u16))
+ (128u64 as u16))
} |
((mStrokeWidthFromObject as u8 as u16) << 8usize) &
- (256usize as u16))
+ (256u64 as u16))
}
}
diff --git a/tests/headers/bitfield-32bit-overflow.h b/tests/headers/bitfield-32bit-overflow.h
new file mode 100644
index 00000000..90796996
--- /dev/null
+++ b/tests/headers/bitfield-32bit-overflow.h
@@ -0,0 +1,36 @@
+
+struct MuchBitfield {
+ char m0 : 1;
+ char m1 : 1;
+ char m2 : 1;
+ char m3 : 1;
+ char m4 : 1;
+ char m5 : 1;
+ char m6 : 1;
+ char m7 : 1;
+ char m8 : 1;
+ char m9 : 1;
+ char m10 : 1;
+ char m11 : 1;
+ char m12 : 1;
+ char m13 : 1;
+ char m14 : 1;
+ char m15 : 1;
+ char m16 : 1;
+ char m17 : 1;
+ char m18 : 1;
+ char m19 : 1;
+ char m20 : 1;
+ char m21 : 1;
+ char m22 : 1;
+ char m23 : 1;
+ char m24 : 1;
+ char m25 : 1;
+ char m26 : 1;
+ char m27 : 1;
+ char m28 : 1;
+ char m29 : 1;
+ char m30 : 1;
+ char m31 : 1;
+ char m32 : 1;
+};
diff --git a/tests/headers/bitfield_align.h b/tests/headers/bitfield_align.h
index 5316b697..7b9527a2 100644
--- a/tests/headers/bitfield_align.h
+++ b/tests/headers/bitfield_align.h
@@ -40,12 +40,10 @@ struct Date2 {
unsigned char byte : 8;
};
-// FIXME(#734)
-//
-// struct Date3 {
-// 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;
-// };
+struct Date3 {
+ 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/class_nested.hpp b/tests/headers/class_nested.hpp
index ccf2f895..208bc4be 100644
--- a/tests/headers/class_nested.hpp
+++ b/tests/headers/class_nested.hpp
@@ -31,6 +31,6 @@ class Templated {
class Templated_inner {
public:
T* member_ptr;
- void get() {}
+ void get();
};
};
diff --git a/tests/headers/enum_and_vtable_mangling.hpp b/tests/headers/enum_and_vtable_mangling.hpp
index 3abd6a29..4c7f4d2b 100644
--- a/tests/headers/enum_and_vtable_mangling.hpp
+++ b/tests/headers/enum_and_vtable_mangling.hpp
@@ -7,5 +7,5 @@ enum {
class C {
int i;
public:
- virtual void match() { };
+ virtual void match();
};
diff --git a/tests/headers/issue-739-pointer-wide-bitfield.h b/tests/headers/issue-739-pointer-wide-bitfield.h
new file mode 100644
index 00000000..611dab1d
--- /dev/null
+++ b/tests/headers/issue-739-pointer-wide-bitfield.h
@@ -0,0 +1,8 @@
+#define POINTER_WIDTH (sizeof(void*) * 8)
+
+struct Foo {
+ unsigned long m_bitfield: POINTER_WIDTH;
+ unsigned long m_bar: POINTER_WIDTH;
+ unsigned long foo: 1;
+ unsigned long bar: POINTER_WIDTH;
+};
diff --git a/tests/headers/issue-769-bad-instantiation-test.hpp b/tests/headers/issue-769-bad-instantiation-test.hpp
new file mode 100644
index 00000000..1be89a66
--- /dev/null
+++ b/tests/headers/issue-769-bad-instantiation-test.hpp
@@ -0,0 +1,11 @@
+// bindgen-flags: --enable-cxx-namespaces --whitelist-type Rooted
+
+template <typename T>
+class Rooted {
+ T member;
+};
+
+class AutoValueVector : Rooted<int> {
+ using Alias = int;
+ using RootedAlias = Rooted<Alias>;
+};
diff --git a/tests/headers/jsval_layout_opaque.hpp b/tests/headers/jsval_layout_opaque.hpp
index 85c5be63..8f36f77d 100644
--- a/tests/headers/jsval_layout_opaque.hpp
+++ b/tests/headers/jsval_layout_opaque.hpp
@@ -1,4 +1,4 @@
-// bindgen-flags: --no-unstable-rust -- -std=c++11
+// bindgen-flags: -- -std=c++11
/**
* These typedefs are hacky, but keep our tests consistent across 64-bit
diff --git a/tests/headers/macro-expr-uncommon-token.h b/tests/headers/macro-expr-uncommon-token.h
new file mode 100644
index 00000000..dd1b4343
--- /dev/null
+++ b/tests/headers/macro-expr-uncommon-token.h
@@ -0,0 +1,7 @@
+
+// Commenting this out & removing the usage before `foo` results in the correct
+// bindings
+#define MODBUS_API
+#define MODBUS_WOOT 3
+
+MODBUS_API void foo();
diff --git a/tests/headers/mangling-macos.h b/tests/headers/mangling-macos.h
new file mode 100644
index 00000000..230f938b
--- /dev/null
+++ b/tests/headers/mangling-macos.h
@@ -0,0 +1,3 @@
+// bindgen-flags: -- --target=x86_64-apple-darwin
+
+void foo();
diff --git a/tests/headers/mangling-win32.h b/tests/headers/mangling-win32.h
new file mode 100644
index 00000000..897aeb42
--- /dev/null
+++ b/tests/headers/mangling-win32.h
@@ -0,0 +1,3 @@
+// bindgen-flags: -- --target=i686-pc-win32
+
+void foo();
diff --git a/tests/headers/only_bitfields.hpp b/tests/headers/only_bitfields.hpp
index 84db0586..793bc66b 100644
--- a/tests/headers/only_bitfields.hpp
+++ b/tests/headers/only_bitfields.hpp
@@ -1,4 +1,3 @@
-// bindgen-flags: --no-unstable-rust
class C {
bool a: 1;
bool b: 7;
diff --git a/tests/headers/prepend-enum-constified-variant.h b/tests/headers/prepend-enum-constified-variant.h
new file mode 100644
index 00000000..aa526ffb
--- /dev/null
+++ b/tests/headers/prepend-enum-constified-variant.h
@@ -0,0 +1,6 @@
+// bindgen-flags: --no-prepend-enum-name
+
+enum AVCodecID {
+ AV_CODEC_ID_FIRST_UNKNOWN = 0x18000,
+ AV_CODEC_ID_TTF = 0x18000,
+};
diff --git a/tests/headers/struct_with_bitfields.h b/tests/headers/struct_with_bitfields.h
index 107fb136..ece512cd 100644
--- a/tests/headers/struct_with_bitfields.h
+++ b/tests/headers/struct_with_bitfields.h
@@ -1,4 +1,3 @@
-// bindgen-flags: --no-unstable-rust
struct bitfield {
unsigned short
a :1,
diff --git a/tests/headers/template-with-var.hpp b/tests/headers/template-with-var.hpp
new file mode 100644
index 00000000..88f60d21
--- /dev/null
+++ b/tests/headers/template-with-var.hpp
@@ -0,0 +1,7 @@
+template<typename T>
+class TemplateWithVar {
+ // We shouldn't generate bindings for this because there are potentially
+ // many instantiations of this variable, but we can't know which ones exist
+ // or don't.
+ static T var = 0;
+};
diff --git a/tests/headers/template.hpp b/tests/headers/template.hpp
index c13643c3..29a0792b 100644
--- a/tests/headers/template.hpp
+++ b/tests/headers/template.hpp
@@ -137,8 +137,3 @@ class ReplacedWithDestructorDeclaredAfter {
T* buff;
~ReplacedWithDestructorDeclaredAfter() {};
};
-
-template<typename T>
-class TemplateWithVar {
- static T var = 0;
-};
diff --git a/tests/headers/union_with_anon_struct_bitfield.h b/tests/headers/union_with_anon_struct_bitfield.h
index 24c7dce8..9668ce40 100644
--- a/tests/headers/union_with_anon_struct_bitfield.h
+++ b/tests/headers/union_with_anon_struct_bitfield.h
@@ -1,4 +1,3 @@
-// bindgen-flags: --no-unstable-rust
union foo {
int a;
struct {
diff --git a/tests/headers/virtual_overloaded.hpp b/tests/headers/virtual_overloaded.hpp
index 8aea8a19..f5ba5ff2 100644
--- a/tests/headers/virtual_overloaded.hpp
+++ b/tests/headers/virtual_overloaded.hpp
@@ -1,5 +1,5 @@
class C {
public:
- virtual void do_thing(char) { };
- virtual void do_thing(int) { };
+ virtual void do_thing(char);
+ virtual void do_thing(int);
};
diff --git a/tests/headers/vtable_recursive_sig.hpp b/tests/headers/vtable_recursive_sig.hpp
index 8729be00..8a073864 100644
--- a/tests/headers/vtable_recursive_sig.hpp
+++ b/tests/headers/vtable_recursive_sig.hpp
@@ -3,9 +3,9 @@
class Derived;
class Base {
public:
- virtual Derived* AsDerived() { return nullptr; }
+ virtual Derived* AsDerived();
};
class Derived final : public Base {
- virtual Derived* AsDerived() override { return this; }
+ virtual Derived* AsDerived() override;
};
diff --git a/tests/headers/weird_bitfields.hpp b/tests/headers/weird_bitfields.hpp
index 755681c1..68cbf4a5 100644
--- a/tests/headers/weird_bitfields.hpp
+++ b/tests/headers/weird_bitfields.hpp
@@ -1,4 +1,3 @@
-// bindgen-flags: --no-unstable-rust
// You can guess where this is taken from...
enum nsStyleSVGOpacitySource {
eStyleSVGOpacitySource_Normal,
diff --git a/tests/test-one.sh b/tests/test-one.sh
index ac466164..caa644fc 100755
--- a/tests/test-one.sh
+++ b/tests/test-one.sh
@@ -10,13 +10,34 @@
set -eu
-cd $(dirname $0)
+if [ $# -ne 1 ]; then
+ echo "Usage: $0 <fuzzy-name>"
+ exit 1
+fi
+
+cd "$(dirname "$0")"
cd ..
export RUST_BACKTRACE=1
-# Grab the first match
-TEST=$(find ./tests/headers -type f -iname "*$1*" | head -n 1)
+unique_fuzzy_file() {
+ local pattern="$1"
+ local results="$(find ./tests/headers -type f | egrep -i "*$pattern*")"
+ local num_results=$(echo "$results" | wc -l)
+
+ if [[ -z "$results" ]]; then
+ >&2 echo "ERROR: no files found with pattern \"$pattern\""
+ exit 1
+ elif [[ "$num_results" -ne 1 ]]; then
+ >&2 echo "ERROR: Expected exactly 1 result, got $num_results:"
+ >&2 echo "$results"
+ exit 1
+ fi
+
+ echo "$results"
+}
+
+TEST="$(unique_fuzzy_file "$1")"
BINDINGS=$(mktemp -t bindings.rs.XXXXXX)
TEST_BINDINGS_BINARY=$(mktemp -t bindings.XXXXXX)
@@ -24,7 +45,7 @@ TEST_BINDINGS_BINARY=$(mktemp -t bindings.XXXXXX)
FLAGS="$(grep "// bindgen-flags: " "$TEST" || echo)"
FLAGS="${FLAGS/\/\/ bindgen\-flags:/}"
# Prepend the default flags added in test.rs's `create_bindgen_builder`.
-FLAGS="--no-unstable-rust --with-derive-default --raw-line '' --raw-line '#![allow(dead_code, non_snake_case, non_camel_case_types, non_upper_case_globals)]' --raw-line '' $FLAGS"
+FLAGS="--with-derive-default --raw-line '' --raw-line '#![allow(dead_code, non_snake_case, non_camel_case_types, non_upper_case_globals)]' --raw-line '' $FLAGS"
eval ./target/debug/bindgen \
diff --git a/tests/tests.rs b/tests/tests.rs
index 46f83155..c1d79954 100644
--- a/tests/tests.rs
+++ b/tests/tests.rs
@@ -146,7 +146,7 @@ fn create_bindgen_builder(header: &PathBuf) -> Result<Option<Builder>, Error> {
.chain(flags.into_iter());
builder_from_flags(args)
- .map(|(builder, _, _)| Some(builder.no_unstable_rust()))
+ .map(|(builder, _, _)| Some(builder))
}
macro_rules! test_header {
@@ -177,7 +177,6 @@ include!(concat!(env!("OUT_DIR"), "/tests.rs"));
fn test_header_contents() {
let bindings = builder()
.header_contents("test.h", "int foo(const char* a);")
- .no_unstable_rust()
.generate()
.unwrap()
.to_string();