diff options
101 files changed, 4827 insertions, 870 deletions
@@ -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 @@ -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)", @@ -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 } } @@ -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(); |