[INFO] fetching crate yamm-sys 0.1.0... [INFO] testing yamm-sys-0.1.0 against try#b83b707f97d809763b7861afa7638871f3339a33 for pr-145838-1 [INFO] extracting crate yamm-sys 0.1.0 into /workspace/builds/worker-5-tc2/source [INFO] started tweaking crates.io crate yamm-sys 0.1.0 [INFO] finished tweaking crates.io crate yamm-sys 0.1.0 [INFO] tweaked toml for crates.io crate yamm-sys 0.1.0 written to /workspace/builds/worker-5-tc2/source/Cargo.toml [INFO] validating manifest of crates.io crate yamm-sys 0.1.0 on toolchain b83b707f97d809763b7861afa7638871f3339a33 [INFO] running `Command { std: CARGO_HOME="/workspace/cargo-home" RUSTUP_HOME="/workspace/rustup-home" "/workspace/cargo-home/bin/cargo" "+b83b707f97d809763b7861afa7638871f3339a33" "metadata" "--manifest-path" "Cargo.toml" "--no-deps", kill_on_drop: false }` [INFO] running `Command { std: CARGO_HOME="/workspace/cargo-home" RUSTUP_HOME="/workspace/rustup-home" "/workspace/cargo-home/bin/cargo" "+b83b707f97d809763b7861afa7638871f3339a33" "generate-lockfile" "--manifest-path" "Cargo.toml", kill_on_drop: false }` [INFO] [stderr] Updating crates.io index [INFO] [stderr] Locking 54 packages to latest compatible versions [INFO] [stderr] Adding bindgen v0.69.5 (available: v0.72.1) [INFO] running `Command { std: CARGO_HOME="/workspace/cargo-home" RUSTUP_HOME="/workspace/rustup-home" "/workspace/cargo-home/bin/cargo" "+b83b707f97d809763b7861afa7638871f3339a33" "fetch" "--manifest-path" "Cargo.toml", kill_on_drop: false }` [INFO] running `Command { std: "docker" "create" "-v" "/var/lib/crater-agent-workspace/builds/worker-5-tc2/target:/opt/rustwide/target:rw,Z" "-v" "/var/lib/crater-agent-workspace/builds/worker-5-tc2/source:/opt/rustwide/workdir:ro,Z" "-v" "/var/lib/crater-agent-workspace/cargo-home:/opt/rustwide/cargo-home:ro,Z" "-v" "/var/lib/crater-agent-workspace/rustup-home:/opt/rustwide/rustup-home:ro,Z" "-e" "SOURCE_DIR=/opt/rustwide/workdir" "-e" "CARGO_TARGET_DIR=/opt/rustwide/target" "-e" "CARGO_HOME=/opt/rustwide/cargo-home" "-e" "RUSTUP_HOME=/opt/rustwide/rustup-home" "-w" "/opt/rustwide/workdir" "-m" "1610612736" "--user" "0:0" "--network" "none" "ghcr.io/rust-lang/crates-build-env/linux@sha256:7ad1b28ee6f5f7f699f6cf7015098d6ccdd96d6f2d78dd06228f5b4c9faf309c" "/opt/rustwide/cargo-home/bin/cargo" "+b83b707f97d809763b7861afa7638871f3339a33" "metadata" "--no-deps" "--format-version=1", kill_on_drop: false }` [INFO] [stdout] 2ef184938026f3ef3ced55ec6b53ec1fabde5639ba5434e46cf24079be3c8a48 [INFO] running `Command { std: "docker" "start" "-a" "2ef184938026f3ef3ced55ec6b53ec1fabde5639ba5434e46cf24079be3c8a48", kill_on_drop: false }` [INFO] running `Command { std: "docker" "inspect" "2ef184938026f3ef3ced55ec6b53ec1fabde5639ba5434e46cf24079be3c8a48", kill_on_drop: false }` [INFO] running `Command { std: "docker" "rm" "-f" "2ef184938026f3ef3ced55ec6b53ec1fabde5639ba5434e46cf24079be3c8a48", kill_on_drop: false }` [INFO] [stdout] 2ef184938026f3ef3ced55ec6b53ec1fabde5639ba5434e46cf24079be3c8a48 [INFO] running `Command { std: "docker" "create" "-v" "/var/lib/crater-agent-workspace/builds/worker-5-tc2/target:/opt/rustwide/target:rw,Z" "-v" "/var/lib/crater-agent-workspace/builds/worker-5-tc2/source:/opt/rustwide/workdir:ro,Z" "-v" "/var/lib/crater-agent-workspace/cargo-home:/opt/rustwide/cargo-home:ro,Z" "-v" "/var/lib/crater-agent-workspace/rustup-home:/opt/rustwide/rustup-home:ro,Z" "-e" "SOURCE_DIR=/opt/rustwide/workdir" "-e" "CARGO_TARGET_DIR=/opt/rustwide/target" "-e" "CARGO_INCREMENTAL=0" "-e" "RUST_BACKTRACE=full" "-e" "RUSTFLAGS=--cap-lints=forbid" "-e" "RUSTDOCFLAGS=--cap-lints=forbid" "-e" "CARGO_HOME=/opt/rustwide/cargo-home" "-e" "RUSTUP_HOME=/opt/rustwide/rustup-home" "-w" "/opt/rustwide/workdir" "-m" "1610612736" "--user" "0:0" "--network" "none" "ghcr.io/rust-lang/crates-build-env/linux@sha256:7ad1b28ee6f5f7f699f6cf7015098d6ccdd96d6f2d78dd06228f5b4c9faf309c" "/opt/rustwide/cargo-home/bin/cargo" "+b83b707f97d809763b7861afa7638871f3339a33" "build" "--frozen" "--message-format=json", kill_on_drop: false }` [INFO] [stdout] 334da9a214660306cb6b4625890dae6685be015c86b3c54f18975931ead55dc7 [INFO] running `Command { std: "docker" "start" "-a" "334da9a214660306cb6b4625890dae6685be015c86b3c54f18975931ead55dc7", kill_on_drop: false }` [INFO] [stderr] Compiling regex-syntax v0.8.6 [INFO] [stderr] Compiling syn v2.0.106 [INFO] [stderr] Compiling bindgen v0.69.5 [INFO] [stderr] Compiling itertools v0.12.1 [INFO] [stderr] Compiling regex-automata v0.4.10 [INFO] [stderr] Compiling regex v1.11.2 [INFO] [stderr] Compiling prettyplease v0.2.37 [INFO] [stderr] Compiling yamm-sys v0.1.0 (/opt/rustwide/workdir) [INFO] [stdout] error[E0740]: field must implement `Copy` or be wrapped in `ManuallyDrop<...>` to be used in a union [INFO] [stdout] --> /opt/rustwide/target/debug/build/yamm-sys-6fee702e1a71bac7/out/bindings.rs:3:20610 [INFO] [stdout] | [INFO] [stdout] 3 | ...e < _Tp > { pub _M_byte : :: std :: os :: raw :: c_uchar , pub _M_val : _Tp , pub _phantom_0 : :: std :: marker :: PhantomData < :: st... [INFO] [stdout] | ^^^^^^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = note: union fields must not have drop side-effects, which is currently enforced via either `Copy` or `ManuallyDrop<...>` [INFO] [stdout] help: wrap the field type in `ManuallyDrop<...>` [INFO] [stdout] | [INFO] [stdout] 3 | # [repr (C)] pub struct __BindgenUnionField < T > (:: std :: marker :: PhantomData < T >) ; impl < T > __BindgenUnionField < T > { # [inline] pub const fn new () -> Self { __BindgenUnionField (:: std :: marker :: PhantomData) } # [inline] pub unsafe fn as_ref (& self) -> & T { :: std :: mem :: transmute (self) } # [inline] pub unsafe fn as_mut (& mut self) -> & mut T { :: std :: mem :: transmute (self) } } impl < T > :: std :: default :: Default for __BindgenUnionField < T > { # [inline] fn default () -> Self { Self :: new () } } impl < T > :: std :: clone :: Clone for __BindgenUnionField < T > { # [inline] fn clone (& self) -> Self { * self } } impl < T > :: std :: marker :: Copy for __BindgenUnionField < T > { } impl < T > :: std :: fmt :: Debug for __BindgenUnionField < T > { fn fmt (& self , fmt : & mut :: std :: fmt :: Formatter < '_ >) -> :: std :: fmt :: Result { fmt . write_str ("__BindgenUnionField") } } impl < T > :: std :: hash :: Hash for __BindgenUnionField < T > { fn hash < H : :: std :: hash :: Hasher > (& self , _state : & mut H) { } } impl < T > :: std :: cmp :: PartialEq for __BindgenUnionField < T > { fn eq (& self , _other : & __BindgenUnionField < T >) -> bool { true } } impl < T > :: std :: cmp :: Eq for __BindgenUnionField < T > { } # [repr (C)] pub struct std_basic_string < _CharT > { pub _M_dataplus : std_basic_string__Alloc_hider , pub _M_string_length : std_basic_string_size_type , pub __bindgen_anon_1 : std_basic_string__bindgen_ty_2 < _CharT > , pub _phantom_0 : :: std :: marker :: PhantomData < :: std :: cell :: UnsafeCell < _CharT > > , } pub type std_basic_string__Char_alloc_type = [u8 ; 0usize] ; pub type std_basic_string__Alloc_traits = __gnu_cxx___alloc_traits ; pub type std_basic_string_traits_type < _Traits > = _Traits ; pub type std_basic_string_value_type = [u8 ; 0usize] ; pub type std_basic_string_allocator_type = std_basic_string__Char_alloc_type ; pub type std_basic_string_size_type = [u8 ; 0usize] ; pub type std_basic_string_difference_type = [u8 ; 0usize] ; pub type std_basic_string_reference = [u8 ; 0usize] ; pub type std_basic_string_const_reference = [u8 ; 0usize] ; pub type std_basic_string_pointer = [u8 ; 0usize] ; pub type std_basic_string_const_pointer = [u8 ; 0usize] ; pub type std_basic_string_iterator = __gnu_cxx___normal_iterator < std_basic_string_pointer > ; pub type std_basic_string_const_iterator = __gnu_cxx___normal_iterator < std_basic_string_const_pointer > ; pub type std_basic_string_const_reverse_iterator = std_reverse_iterator < std_basic_string_const_iterator > ; pub type std_basic_string_reverse_iterator = std_reverse_iterator < std_basic_string_iterator > ; pub type std_basic_string___const_iterator = std_basic_string_const_iterator ; pub type std_basic_string___sv_type < _CharT > = std_basic_string_view < _CharT > ; pub type std_basic_string__If_sv = std_enable_if_t ; # [repr (C)] # [derive (Debug , Copy , Clone)] pub struct std_basic_string___sv_wrapper < _CharT > { pub _M_sv : std_basic_string___sv_type < _CharT > , pub _phantom_0 : :: std :: marker :: PhantomData < :: std :: cell :: UnsafeCell < _CharT > > , } # [repr (C)] pub struct std_basic_string__Alloc_hider { pub _M_p : std_basic_string_pointer , } pub const std_basic_string__S_local_capacity : std_basic_string__bindgen_ty_1 = 0 ; pub type std_basic_string__bindgen_ty_1 = i32 ; # [repr (C)] pub struct std_basic_string__bindgen_ty_2 < _CharT > { pub _M_local_buf : __BindgenUnionField < * mut _CharT > , pub _M_allocated_capacity : __BindgenUnionField < std_basic_string_size_type > , pub bindgen_union_field : u64 , pub _phantom_0 : :: std :: marker :: PhantomData < :: std :: cell :: UnsafeCell < _CharT > > , } pub type std_string = std_basic_string < :: std :: os :: raw :: c_char > ; pub type std_streamoff = :: std :: os :: raw :: c_long ; # [repr (C)] # [derive (Debug)] pub struct std_fpos < _StateT > { pub _M_off : std_streamoff , pub _M_state : _StateT , pub _phantom_0 : :: std :: marker :: PhantomData < :: std :: cell :: UnsafeCell < _StateT > > , } pub type std_streampos = std_fpos < __mbstate_t > ; pub type std_integral_constant_value_type < _Tp > = _Tp ; pub type std_integral_constant_type = u8 ; pub type std_true_type = u8 ; pub type std_false_type = u8 ; pub type std___enable_if_t = u8 ; # [repr (C)] # [derive (Debug , Copy , Clone)] pub struct std___type_identity { pub _address : u8 , } pub type std___type_identity_type < _Type > = _Type ; # [repr (C)] # [derive (Debug , Copy , Clone)] pub struct std___and_ { pub _address : u8 , } # [repr (C)] # [derive (Debug , Copy , Clone)] pub struct std_make_unsigned { pub _address : u8 , } pub type std_make_unsigned_type = u8 ; pub type std_enable_if_t = u8 ; # [repr (C)] # [derive (Debug , Copy , Clone)] pub struct std___detector { pub _address : u8 , } pub type std___detector_type < _Default > = _Default ; pub type std___detector___is_detected = std_false_type ; pub type std___detected_or = std___detector ; pub type std___detected_or_t = std___detected_or ; # [repr (C)] # [derive (Debug , Copy , Clone)] pub struct std_char_traits { pub _address : u8 , } # [repr (C)] # [derive (Debug)] pub struct std___new_allocator { pub _address : u8 , } pub type std___new_allocator_value_type < _Tp > = _Tp ; pub type std___new_allocator_size_type = usize ; pub type std___new_allocator_difference_type = isize ; pub type std___new_allocator_pointer < _Tp > = * mut _Tp ; pub type std___new_allocator_const_pointer < _Tp > = * const _Tp ; pub type std___new_allocator_reference < _Tp > = * mut _Tp ; pub type std___new_allocator_const_reference < _Tp > = * const _Tp ; # [repr (C)] # [derive (Debug , Copy , Clone)] pub struct std___new_allocator_rebind { pub _address : u8 , } pub type std___new_allocator_propagate_on_container_move_assignment = std_true_type ; pub type std___allocator_base = std___new_allocator ; # [repr (C)] # [derive (Debug)] pub struct std_allocator { pub _address : u8 , } pub type std_allocator_value_type < _Tp > = _Tp ; pub type std_allocator_size_type = usize ; pub type std_allocator_difference_type = isize ; pub type std_allocator_pointer < _Tp > = * mut _Tp ; pub type std_allocator_const_pointer < _Tp > = * const _Tp ; pub type std_allocator_reference < _Tp > = * mut _Tp ; pub type std_allocator_const_reference < _Tp > = * const _Tp ; # [repr (C)] # [derive (Debug , Copy , Clone)] pub struct std_allocator_rebind { pub _address : u8 , } pub type std_allocator_rebind_other = std_allocator ; pub type std_allocator_propagate_on_container_move_assignment = std_true_type ; pub type std_allocator_is_always_equal = std_true_type ; # [repr (C)] # [derive (Debug , Copy , Clone)] pub struct std_input_iterator_tag { pub _address : u8 , } # [test] fn bindgen_test_layout_std_input_iterator_tag () { assert_eq ! (:: std :: mem :: size_of :: < std_input_iterator_tag > () , 1usize , concat ! ("Size of: " , stringify ! (std_input_iterator_tag))) ; assert_eq ! (:: std :: mem :: align_of :: < std_input_iterator_tag > () , 1usize , concat ! ("Alignment of " , stringify ! (std_input_iterator_tag))) ; } # [repr (C)] # [derive (Debug , Copy , Clone)] pub struct std_forward_iterator_tag { pub _address : u8 , } # [test] fn bindgen_test_layout_std_forward_iterator_tag () { assert_eq ! (:: std :: mem :: size_of :: < std_forward_iterator_tag > () , 1usize , concat ! ("Size of: " , stringify ! (std_forward_iterator_tag))) ; assert_eq ! (:: std :: mem :: align_of :: < std_forward_iterator_tag > () , 1usize , concat ! ("Alignment of " , stringify ! (std_forward_iterator_tag))) ; } # [repr (C)] # [derive (Debug , Copy , Clone)] pub struct std_bidirectional_iterator_tag { pub _address : u8 , } # [test] fn bindgen_test_layout_std_bidirectional_iterator_tag () { assert_eq ! (:: std :: mem :: size_of :: < std_bidirectional_iterator_tag > () , 1usize , concat ! ("Size of: " , stringify ! (std_bidirectional_iterator_tag))) ; assert_eq ! (:: std :: mem :: align_of :: < std_bidirectional_iterator_tag > () , 1usize , concat ! ("Alignment of " , stringify ! (std_bidirectional_iterator_tag))) ; } # [repr (C)] # [derive (Debug , Copy , Clone)] pub struct std_random_access_iterator_tag { pub _address : u8 , } # [test] fn bindgen_test_layout_std_random_access_iterator_tag () { assert_eq ! (:: std :: mem :: size_of :: < std_random_access_iterator_tag > () , 1usize , concat ! ("Size of: " , stringify ! (std_random_access_iterator_tag))) ; assert_eq ! (:: std :: mem :: align_of :: < std_random_access_iterator_tag > () , 1usize , concat ! ("Alignment of " , stringify ! (std_random_access_iterator_tag))) ; } # [repr (C)] # [derive (Debug , Copy , Clone)] pub struct std_iterator { pub _address : u8 , } pub type std_iterator_iterator_category < _Category > = _Category ; pub type std_iterator_value_type < _Tp > = _Tp ; pub type std_iterator_difference_type < _Distance > = _Distance ; pub type std_iterator_pointer < _Pointer > = _Pointer ; pub type std_iterator_reference < _Reference > = _Reference ; # [repr (C)] # [derive (Debug , Copy , Clone)] pub struct std___iterator_traits { pub _address : u8 , } # [repr (C)] # [derive (Debug , Copy , Clone)] pub struct std_iterator_traits { pub _address : u8 , } # [repr (C)] # [derive (Debug , Copy , Clone)] pub struct std___undefined { _unused : [u8 ; 0] , } # [repr (C)] # [derive (Debug , Copy , Clone)] pub struct std___get_first_arg { pub _address : u8 , } pub type std___get_first_arg_type = std___undefined ; # [repr (C)] # [derive (Debug , Copy , Clone)] pub struct std___replace_first_arg { pub _address : u8 , } # [repr (C)] # [derive (Debug , Copy , Clone)] pub struct std___ptr_traits_elem { pub _address : u8 , } pub type std___ptr_traits_elem_t = std___ptr_traits_elem ; pub type std___ptr_traits_ptr_to_pointer < _Ptr > = _Ptr ; pub type std___ptr_traits_ptr_to_element_type < _Elt > = _Elt ; # [repr (C)] # [derive (Debug , Copy , Clone)] pub struct std___ptr_traits_impl { pub _address : u8 , } pub type std___ptr_traits_impl___diff_t = [u8 ; 0usize] ; pub type std___ptr_traits_impl___rebind = std___type_identity ; pub type std___ptr_traits_impl_pointer < _Ptr > = _Ptr ; pub type std___ptr_traits_impl_element_type < _Elt > = _Elt ; pub type std___ptr_traits_impl_difference_type = std___detected_or_t ; pub type std___ptr_traits_impl_rebind = std___detected_or_t ; # [repr (C)] # [derive (Debug , Copy , Clone)] pub struct std_pointer_traits { pub _address : u8 , } pub type std___ptr_rebind = std_pointer_traits ; # [repr (C)] # [derive (Debug , Copy , Clone)] pub struct std_reverse_iterator < _Iterator > { pub current : _Iterator , pub _phantom_0 : :: std :: marker :: PhantomData < :: std :: cell :: UnsafeCell < _Iterator > > , } pub type std_reverse_iterator___traits_type = std_iterator_traits ; pub type std_reverse_iterator_iterator_type < _Iterator > = _Iterator ; pub type std_reverse_iterator_pointer = std_reverse_iterator___traits_type ; pub type std_reverse_iterator_difference_type = std_reverse_iterator___traits_type ; pub type std_reverse_iterator_reference = std_reverse_iterator___traits_type ; # [repr (C)] # [derive (Debug , Copy , Clone)] pub struct std___allocator_traits_base { pub _address : u8 , } # [repr (C)] # [derive (Debug , Copy , Clone)] pub struct std___allocator_traits_base___rebind { pub _address : u8 , } pub type std___allocator_traits_base___pointer = [u8 ; 0usize] ; pub type std___allocator_traits_base___c_pointer = [u8 ; 0usize] ; pub type std___allocator_traits_base___v_pointer = [u8 ; 0usize] ; pub type std___allocator_traits_base___cv_pointer = [u8 ; 0usize] ; pub type std___allocator_traits_base___pocca = [u8 ; 0usize] ; pub type std___allocator_traits_base___pocma = [u8 ; 0usize] ; pub type std___allocator_traits_base___pocs = [u8 ; 0usize] ; pub type std___allocator_traits_base___equal = std___type_identity ; # [test] fn bindgen_test_layout_std___allocator_traits_base () { assert_eq ! (:: std :: mem :: size_of :: < std___allocator_traits_base > () , 1usize , concat ! ("Size of: " , stringify ! (std___allocator_traits_base))) ; assert_eq ! (:: std :: mem :: align_of :: < std___allocator_traits_base > () , 1usize , concat ! ("Alignment of " , stringify ! (std___allocator_traits_base))) ; } pub type std___alloc_rebind = std___allocator_traits_base ; # [repr (C)] # [derive (Debug , Copy , Clone)] pub struct std_allocator_traits { pub _address : u8 , } pub type std_allocator_traits_allocator_type < _Alloc > = _Alloc ; pub type std_allocator_traits_value_type = [u8 ; 0usize] ; pub type std_allocator_traits_pointer = std___detected_or_t ; # [repr (C)] # [derive (Debug , Copy , Clone)] pub struct std_allocator_traits__Ptr { pub _address : u8 , } pub type std_allocator_traits__Ptr_type = [u8 ; 0usize] ; # [repr (C)] # [derive (Debug , Copy , Clone)] pub struct std_allocator_traits__Diff { pub _address : u8 , } pub type std_allocator_traits__Diff_type = std_pointer_traits ; # [repr (C)] # [derive (Debug , Copy , Clone)] pub struct std_allocator_traits__Size { pub _address : u8 , } pub type std_allocator_traits_const_pointer = [u8 ; 0usize] ; pub type std_allocator_traits_void_pointer = std_allocator_traits__Ptr ; pub type std_allocator_traits_const_void_pointer = std_allocator_traits__Ptr ; pub type std_allocator_traits_difference_type = [u8 ; 0usize] ; pub type std_allocator_traits_size_type = [u8 ; 0usize] ; pub type std_allocator_traits_propagate_on_container_copy_assignment = std___detected_or_t ; pub type std_allocator_traits_propagate_on_container_move_assignment = std___detected_or_t ; pub type std_allocator_traits_propagate_on_container_swap = std___detected_or_t ; pub type std_allocator_traits_is_always_equal = std___detected_or_t ; pub type std_allocator_traits_rebind_alloc = std___alloc_rebind ; pub type std_allocator_traits_rebind_traits = std_allocator_traits ; # [repr (C)] # [derive (Debug , Copy , Clone)] pub struct std_allocator_traits___construct_helper { pub _address : u8 , } pub type std_allocator_traits___construct_helper_type < _Alloc > = _Alloc ; pub type std_allocator_traits___has_construct = std_allocator_traits___construct_helper ; # [repr (C)] # [derive (Debug , Copy , Clone)] pub struct std_basic_string_view < _CharT > { pub _M_len : usize , pub _M_str : * const _CharT , pub _phantom_0 : :: std :: marker :: PhantomData < :: std :: cell :: UnsafeCell < _CharT > > , } pub type std_basic_string_view_traits_type < _Traits > = _Traits ; pub type std_basic_string_view_value_type < _CharT > = _CharT ; pub type std_basic_string_view_pointer < _CharT > = * mut std_basic_string_view_value_type < _CharT > ; pub type std_basic_string_view_const_pointer < _CharT > = * const std_basic_string_view_value_type < _CharT > ; pub type std_basic_string_view_reference < _CharT > = * mut std_basic_string_view_value_type < _CharT > ; pub type std_basic_string_view_const_reference < _CharT > = * const std_basic_string_view_value_type < _CharT > ; pub type std_basic_string_view_const_iterator < _CharT > = * const std_basic_string_view_value_type < _CharT > ; pub type std_basic_string_view_iterator < _CharT > = std_basic_string_view_const_iterator < _CharT > ; pub type std_basic_string_view_const_reverse_iterator < _CharT > = std_reverse_iterator < std_basic_string_view_const_iterator < _CharT > > ; pub type std_basic_string_view_reverse_iterator < _CharT > = std_basic_string_view_const_reverse_iterator < _CharT > ; pub type std_basic_string_view_size_type = usize ; pub type std_basic_string_view_difference_type = isize ; # [repr (C)] # [derive (Debug , Copy , Clone)] pub struct std__Deque_iterator { pub _M_cur : std__Deque_iterator__Elt_pointer , pub _M_first : std__Deque_iterator__Elt_pointer , pub _M_last : std__Deque_iterator__Elt_pointer , pub _M_node : std__Deque_iterator__Map_pointer , } pub type std__Deque_iterator___iter = std__Deque_iterator ; pub type std__Deque_iterator_iterator = std__Deque_iterator___iter ; pub type std__Deque_iterator_const_iterator = std__Deque_iterator___iter ; pub type std__Deque_iterator__Elt_pointer = std___ptr_rebind ; pub type std__Deque_iterator__Map_pointer = std___ptr_rebind ; pub type std__Deque_iterator_iterator_category = std_random_access_iterator_tag ; pub type std__Deque_iterator_value_type < _Tp > = _Tp ; pub type std__Deque_iterator_pointer < _Ptr > = _Ptr ; pub type std__Deque_iterator_reference < _Ref > = _Ref ; pub type std__Deque_iterator_size_type = usize ; pub type std__Deque_iterator_difference_type = isize ; pub type std__Deque_iterator__Self = std__Deque_iterator ; # [repr (C)] pub struct std__Deque_base { pub _M_impl : std__Deque_base__Deque_impl , } pub type std__Deque_base__Tp_alloc_type = [u8 ; 0usize] ; pub type std__Deque_base__Alloc_traits = __gnu_cxx___alloc_traits ; pub type std__Deque_base__Ptr = [u8 ; 0usize] ; pub type std__Deque_base__Ptr_const = [u8 ; 0usize] ; pub type std__Deque_base__Map_alloc_type = [u8 ; 0usize] ; pub type std__Deque_base__Map_alloc_traits = __gnu_cxx___alloc_traits ; pub type std__Deque_base_allocator_type < _Alloc > = _Alloc ; pub type std__Deque_base_iterator = std__Deque_iterator ; pub type std__Deque_base_const_iterator = std__Deque_iterator ; pub type std__Deque_base__Map_pointer = [u8 ; 0usize] ; # [repr (C)] pub struct std__Deque_base__Deque_impl_data { pub _M_map : std__Deque_base__Map_pointer , pub _M_map_size : usize , pub _M_start : std__Deque_base_iterator , pub _M_finish : std__Deque_base_iterator , } # [repr (C)] pub struct std__Deque_base__Deque_impl { pub _base_1 : std__Deque_base__Deque_impl_data , } pub const std__Deque_base__S_initial_map_size : std__Deque_base__bindgen_ty_1 = 0 ; pub type std__Deque_base__bindgen_ty_1 = i32 ; # [repr (C)] pub struct std_deque { pub _base : std__Deque_base , } pub type std_deque__Base = std__Deque_base ; pub type std_deque__Tp_alloc_type = std_deque__Base ; pub type std_deque__Alloc_traits = std_deque__Base ; pub type std_deque__Map_pointer = std_deque__Base ; pub type std_deque_value_type < _Tp > = _Tp ; pub type std_deque_pointer = std_deque__Alloc_traits ; pub type std_deque_const_pointer = std_deque__Alloc_traits ; pub type std_deque_reference = std_deque__Alloc_traits ; pub type std_deque_const_reference = std_deque__Alloc_traits ; pub type std_deque_iterator = std_deque__Base ; pub type std_deque_const_iterator = std_deque__Base ; pub type std_deque_const_reverse_iterator = std_reverse_iterator < std_deque_const_iterator > ; pub type std_deque_reverse_iterator = std_reverse_iterator < std_deque_iterator > ; pub type std_deque_size_type = usize ; pub type std_deque_difference_type = isize ; pub type std_deque_allocator_type < _Alloc > = _Alloc ; # [repr (C)] pub struct std__Vector_base { pub _M_impl : std__Vector_base__Vector_impl , } pub type std__Vector_base__Tp_alloc_type = [u8 ; 0usize] ; pub type std__Vector_base_pointer = [u8 ; 0usize] ; # [repr (C)] pub struct std__Vector_base__Vector_impl_data { pub _M_start : std__Vector_base_pointer , pub _M_finish : std__Vector_base_pointer , pub _M_end_of_storage : std__Vector_base_pointer , } # [repr (C)] pub struct std__Vector_base__Vector_impl { pub _base_1 : std__Vector_base__Vector_impl_data , } pub type std__Vector_base_allocator_type < _Alloc > = _Alloc ; # [repr (C)] pub struct std_vector { pub _base : std__Vector_base , } pub type std_vector__Base = std__Vector_base ; pub type std_vector__Tp_alloc_type = std_vector__Base ; pub type std_vector__Alloc_traits = __gnu_cxx___alloc_traits ; pub type std_vector_value_type < _Tp > = _Tp ; pub type std_vector_pointer = std_vector__Base ; pub type std_vector_const_pointer = std_vector__Alloc_traits ; pub type std_vector_reference = std_vector__Alloc_traits ; pub type std_vector_const_reference = std_vector__Alloc_traits ; pub type std_vector_iterator = __gnu_cxx___normal_iterator < std_vector_pointer > ; pub type std_vector_const_iterator = __gnu_cxx___normal_iterator < std_vector_const_pointer > ; pub type std_vector_const_reverse_iterator = std_reverse_iterator < std_vector_const_iterator > ; pub type std_vector_reverse_iterator = std_reverse_iterator < std_vector_iterator > ; pub type std_vector_size_type = usize ; pub type std_vector_difference_type = isize ; pub type std_vector_allocator_type < _Alloc > = _Alloc ; # [repr (C)] pub struct std_vector__Temporary_value < _Tp > { pub _M_this : * mut std_vector , pub _M_storage : std_vector__Temporary_value__Storage < _Tp > , pub _phantom_0 : :: std :: marker :: PhantomData < :: std :: cell :: UnsafeCell < _Tp > > , } # [repr (C)] pub union std_vector__Temporary_value__Storage < _Tp > { pub _M_byte : :: std :: os :: raw :: c_uchar , pub _M_val : std::mem::ManuallyDrop<_Tp> , pub _phantom_0 : :: std :: marker :: PhantomData < :: std :: cell :: UnsafeCell < _Tp > > , } # [repr (C)] # [derive (Debug , Copy , Clone)] pub struct std_queue < _Sequence > { pub c : _Sequence , pub _phantom_0 : :: std :: marker :: PhantomData < :: std :: cell :: UnsafeCell < _Sequence > > , } pub type std_queue__Uses = u8 ; pub type std_queue_value_type = [u8 ; 0usize] ; pub type std_queue_reference = [u8 ; 0usize] ; pub type std_queue_const_reference = [u8 ; 0usize] ; pub type std_queue_size_type = [u8 ; 0usize] ; pub type std_queue_container_type < _Sequence > = _Sequence ; # [repr (C)] # [derive (Debug , Copy , Clone)] pub struct __gnu_cxx__Char_types { pub _address : u8 , } pub type __gnu_cxx__Char_types_int_type = :: std :: os :: raw :: c_ulong ; pub type __gnu_cxx__Char_types_pos_type = std_streampos ; pub type __gnu_cxx__Char_types_off_type = std_streamoff ; pub type __gnu_cxx__Char_types_state_type = __mbstate_t ; # [repr (C)] # [derive (Debug , Copy , Clone)] pub struct __gnu_cxx_char_traits { pub _address : u8 , } pub type __gnu_cxx_char_traits_char_type < _CharT > = _CharT ; pub type __gnu_cxx_char_traits_int_type = __gnu_cxx__Char_types ; pub type __gnu_cxx_char_traits_pos_type = __gnu_cxx__Char_types ; pub type __gnu_cxx_char_traits_off_type = __gnu_cxx__Char_types ; pub type __gnu_cxx_char_traits_state_type = __gnu_cxx__Char_types ; # [repr (C)] # [derive (Debug , Copy , Clone)] pub struct __gnu_cxx___normal_iterator < _Iterator > { pub _M_current : _Iterator , pub _phantom_0 : :: std :: marker :: PhantomData < :: std :: cell :: UnsafeCell < _Iterator > > , } pub type __gnu_cxx___normal_iterator___traits_type = std_iterator_traits ; pub type __gnu_cxx___normal_iterator___convertible_from = std___enable_if_t ; pub type __gnu_cxx___normal_iterator_iterator_type < _Iterator > = _Iterator ; pub type __gnu_cxx___normal_iterator_iterator_category = __gnu_cxx___normal_iterator___traits_type ; pub type __gnu_cxx___normal_iterator_value_type = __gnu_cxx___normal_iterator___traits_type ; pub type __gnu_cxx___normal_iterator_difference_type = __gnu_cxx___normal_iterator___traits_type ; pub type __gnu_cxx___normal_iterator_reference = __gnu_cxx___normal_iterator___traits_type ; pub type __gnu_cxx___normal_iterator_pointer = __gnu_cxx___normal_iterator___traits_type ; # [repr (C)] # [derive (Debug , Copy , Clone)] pub struct __gnu_cxx___alloc_traits { pub _address : u8 , } pub type __gnu_cxx___alloc_traits_allocator_type < _Alloc > = _Alloc ; pub type __gnu_cxx___alloc_traits__Base_type = std_allocator_traits ; pub type __gnu_cxx___alloc_traits_value_type = __gnu_cxx___alloc_traits__Base_type ; pub type __gnu_cxx___alloc_traits_pointer = __gnu_cxx___alloc_traits__Base_type ; pub type __gnu_cxx___alloc_traits_const_pointer = __gnu_cxx___alloc_traits__Base_type ; pub type __gnu_cxx___alloc_traits_size_type = __gnu_cxx___alloc_traits__Base_type ; pub type __gnu_cxx___alloc_traits_difference_type = __gnu_cxx___alloc_traits__Base_type ; pub type __gnu_cxx___alloc_traits_reference = * mut __gnu_cxx___alloc_traits_value_type ; pub type __gnu_cxx___alloc_traits_const_reference = * const __gnu_cxx___alloc_traits_value_type ; pub type __gnu_cxx___alloc_traits___is_custom_pointer = std___and_ ; # [repr (C)] # [derive (Debug , Copy , Clone)] pub struct __gnu_cxx___alloc_traits_rebind { pub _address : u8 , } pub type __gnu_cxx___alloc_traits_rebind_other = __gnu_cxx___alloc_traits__Base_type ; # [repr (C)] # [derive (Copy , Clone)] pub struct __mbstate_t { pub __count : :: std :: os :: raw :: c_int , pub __value : __mbstate_t__bindgen_ty_1 , } # [repr (C)] # [derive (Copy , Clone)] pub union __mbstate_t__bindgen_ty_1 { pub __wch : :: std :: os :: raw :: c_uint , pub __wchb : [:: std :: os :: raw :: c_char ; 4usize] , } # [test] fn bindgen_test_layout___mbstate_t__bindgen_ty_1 () { const UNINIT : :: std :: mem :: MaybeUninit < __mbstate_t__bindgen_ty_1 > = :: std :: mem :: MaybeUninit :: uninit () ; let ptr = UNINIT . as_ptr () ; assert_eq ! (:: std :: mem :: size_of :: < __mbstate_t__bindgen_ty_1 > () , 4usize , concat ! ("Size of: " , stringify ! (__mbstate_t__bindgen_ty_1))) ; assert_eq ! (:: std :: mem :: align_of :: < __mbstate_t__bindgen_ty_1 > () , 4usize , concat ! ("Alignment of " , stringify ! (__mbstate_t__bindgen_ty_1))) ; assert_eq ! (unsafe { :: std :: ptr :: addr_of ! ((* ptr) . __wch) as usize - ptr as usize } , 0usize , concat ! ("Offset of field: " , stringify ! (__mbstate_t__bindgen_ty_1) , "::" , stringify ! (__wch))) ; assert_eq ! (unsafe { :: std :: ptr :: addr_of ! ((* ptr) . __wchb) as usize - ptr as usize } , 0usize , concat ! ("Offset of field: " , stringify ! (__mbstate_t__bindgen_ty_1) , "::" , stringify ! (__wchb))) ; } # [test] fn bindgen_test_layout___mbstate_t () { const UNINIT : :: std :: mem :: MaybeUninit < __mbstate_t > = :: std :: mem :: MaybeUninit :: uninit () ; let ptr = UNINIT . as_ptr () ; assert_eq ! (:: std :: mem :: size_of :: < __mbstate_t > () , 8usize , concat ! ("Size of: " , stringify ! (__mbstate_t))) ; assert_eq ! (:: std :: mem :: align_of :: < __mbstate_t > () , 4usize , concat ! ("Alignment of " , stringify ! (__mbstate_t))) ; assert_eq ! (unsafe { :: std :: ptr :: addr_of ! ((* ptr) . __count) as usize - ptr as usize } , 0usize , concat ! ("Offset of field: " , stringify ! (__mbstate_t) , "::" , stringify ! (__count))) ; assert_eq ! (unsafe { :: std :: ptr :: addr_of ! ((* ptr) . __value) as usize - ptr as usize } , 4usize , concat ! ("Offset of field: " , stringify ! (__mbstate_t) , "::" , stringify ! (__value))) ; } pub type FILE = _IO_FILE ; pub type __off_t = :: std :: os :: raw :: c_long ; pub type __off64_t = :: std :: os :: raw :: c_long ; pub type uint = :: std :: os :: raw :: c_uint ; # [repr (C)] # [derive (Debug , Copy , Clone)] pub struct _IO_marker { _unused : [u8 ; 0] , } # [repr (C)] # [derive (Debug , Copy , Clone)] pub struct _IO_codecvt { _unused : [u8 ; 0] , } # [repr (C)] # [derive (Debug , Copy , Clone)] pub struct _IO_wide_data { _unused : [u8 ; 0] , } pub type _IO_lock_t = :: std :: os :: raw :: c_void ; # [repr (C)] # [derive (Debug , Copy , Clone)] pub struct _IO_FILE { pub _flags : :: std :: os :: raw :: c_int , pub _IO_read_ptr : * mut :: std :: os :: raw :: c_char , pub _IO_read_end : * mut :: std :: os :: raw :: c_char , pub _IO_read_base : * mut :: std :: os :: raw :: c_char , pub _IO_write_base : * mut :: std :: os :: raw :: c_char , pub _IO_write_ptr : * mut :: std :: os :: raw :: c_char , pub _IO_write_end : * mut :: std :: os :: raw :: c_char , pub _IO_buf_base : * mut :: std :: os :: raw :: c_char , pub _IO_buf_end : * mut :: std :: os :: raw :: c_char , pub _IO_save_base : * mut :: std :: os :: raw :: c_char , pub _IO_backup_base : * mut :: std :: os :: raw :: c_char , pub _IO_save_end : * mut :: std :: os :: raw :: c_char , pub _markers : * mut _IO_marker , pub _chain : * mut _IO_FILE , pub _fileno : :: std :: os :: raw :: c_int , pub _flags2 : :: std :: os :: raw :: c_int , pub _old_offset : __off_t , pub _cur_column : :: std :: os :: raw :: c_ushort , pub _vtable_offset : :: std :: os :: raw :: c_schar , pub _shortbuf : [:: std :: os :: raw :: c_char ; 1usize] , pub _lock : * mut _IO_lock_t , pub _offset : __off64_t , pub _codecvt : * mut _IO_codecvt , pub _wide_data : * mut _IO_wide_data , pub _freeres_list : * mut _IO_FILE , pub _freeres_buf : * mut :: std :: os :: raw :: c_void , pub __pad5 : usize , pub _mode : :: std :: os :: raw :: c_int , pub _unused2 : [:: std :: os :: raw :: c_char ; 20usize] , } # [test] fn bindgen_test_layout__IO_FILE () { const UNINIT : :: std :: mem :: MaybeUninit < _IO_FILE > = :: std :: mem :: MaybeUninit :: uninit () ; let ptr = UNINIT . as_ptr () ; assert_eq ! (:: std :: mem :: size_of :: < _IO_FILE > () , 216usize , concat ! ("Size of: " , stringify ! (_IO_FILE))) ; assert_eq ! (:: std :: mem :: align_of :: < _IO_FILE > () , 8usize , concat ! ("Alignment of " , stringify ! (_IO_FILE))) ; assert_eq ! (unsafe { :: std :: ptr :: addr_of ! ((* ptr) . _flags) as usize - ptr as usize } , 0usize , concat ! ("Offset of field: " , stringify ! (_IO_FILE) , "::" , stringify ! (_flags))) ; assert_eq ! (unsafe { :: std :: ptr :: addr_of ! ((* ptr) . _IO_read_ptr) as usize - ptr as usize } , 8usize , concat ! ("Offset of field: " , stringify ! (_IO_FILE) , "::" , stringify ! (_IO_read_ptr))) ; assert_eq ! (unsafe { :: std :: ptr :: addr_of ! ((* ptr) . _IO_read_end) as usize - ptr as usize } , 16usize , concat ! ("Offset of field: " , stringify ! (_IO_FILE) , "::" , stringify ! (_IO_read_end))) ; assert_eq ! (unsafe { :: std :: ptr :: addr_of ! ((* ptr) . _IO_read_base) as usize - ptr as usize } , 24usize , concat ! ("Offset of field: " , stringify ! (_IO_FILE) , "::" , stringify ! (_IO_read_base))) ; assert_eq ! (unsafe { :: std :: ptr :: addr_of ! ((* ptr) . _IO_write_base) as usize - ptr as usize } , 32usize , concat ! ("Offset of field: " , stringify ! (_IO_FILE) , "::" , stringify ! (_IO_write_base))) ; assert_eq ! (unsafe { :: std :: ptr :: addr_of ! ((* ptr) . _IO_write_ptr) as usize - ptr as usize } , 40usize , concat ! ("Offset of field: " , stringify ! (_IO_FILE) , "::" , stringify ! (_IO_write_ptr))) ; assert_eq ! (unsafe { :: std :: ptr :: addr_of ! ((* ptr) . _IO_write_end) as usize - ptr as usize } , 48usize , concat ! ("Offset of field: " , stringify ! (_IO_FILE) , "::" , stringify ! (_IO_write_end))) ; assert_eq ! (unsafe { :: std :: ptr :: addr_of ! ((* ptr) . _IO_buf_base) as usize - ptr as usize } , 56usize , concat ! ("Offset of field: " , stringify ! (_IO_FILE) , "::" , stringify ! (_IO_buf_base))) ; assert_eq ! (unsafe { :: std :: ptr :: addr_of ! ((* ptr) . _IO_buf_end) as usize - ptr as usize } , 64usize , concat ! ("Offset of field: " , stringify ! (_IO_FILE) , "::" , stringify ! (_IO_buf_end))) ; assert_eq ! (unsafe { :: std :: ptr :: addr_of ! ((* ptr) . _IO_save_base) as usize - ptr as usize } , 72usize , concat ! ("Offset of field: " , stringify ! (_IO_FILE) , "::" , stringify ! (_IO_save_base))) ; assert_eq ! (unsafe { :: std :: ptr :: addr_of ! ((* ptr) . _IO_backup_base) as usize - ptr as usize } , 80usize , concat ! ("Offset of field: " , stringify ! (_IO_FILE) , "::" , stringify ! (_IO_backup_base))) ; assert_eq ! (unsafe { :: std :: ptr :: addr_of ! ((* ptr) . _IO_save_end) as usize - ptr as usize } , 88usize , concat ! ("Offset of field: " , stringify ! (_IO_FILE) , "::" , stringify ! (_IO_save_end))) ; assert_eq ! (unsafe { :: std :: ptr :: addr_of ! ((* ptr) . _markers) as usize - ptr as usize } , 96usize , concat ! ("Offset of field: " , stringify ! (_IO_FILE) , "::" , stringify ! (_markers))) ; assert_eq ! (unsafe { :: std :: ptr :: addr_of ! ((* ptr) . _chain) as usize - ptr as usize } , 104usize , concat ! ("Offset of field: " , stringify ! (_IO_FILE) , "::" , stringify ! (_chain))) ; assert_eq ! (unsafe { :: std :: ptr :: addr_of ! ((* ptr) . _fileno) as usize - ptr as usize } , 112usize , concat ! ("Offset of field: " , stringify ! (_IO_FILE) , "::" , stringify ! (_fileno))) ; assert_eq ! (unsafe { :: std :: ptr :: addr_of ! ((* ptr) . _flags2) as usize - ptr as usize } , 116usize , concat ! ("Offset of field: " , stringify ! (_IO_FILE) , "::" , stringify ! (_flags2))) ; assert_eq ! (unsafe { :: std :: ptr :: addr_of ! ((* ptr) . _old_offset) as usize - ptr as usize } , 120usize , concat ! ("Offset of field: " , stringify ! (_IO_FILE) , "::" , stringify ! (_old_offset))) ; assert_eq ! (unsafe { :: std :: ptr :: addr_of ! ((* ptr) . _cur_column) as usize - ptr as usize } , 128usize , concat ! ("Offset of field: " , stringify ! (_IO_FILE) , "::" , stringify ! (_cur_column))) ; assert_eq ! (unsafe { :: std :: ptr :: addr_of ! ((* ptr) . _vtable_offset) as usize - ptr as usize } , 130usize , concat ! ("Offset of field: " , stringify ! (_IO_FILE) , "::" , stringify ! (_vtable_offset))) ; assert_eq ! (unsafe { :: std :: ptr :: addr_of ! ((* ptr) . _shortbuf) as usize - ptr as usize } , 131usize , concat ! ("Offset of field: " , stringify ! (_IO_FILE) , "::" , stringify ! (_shortbuf))) ; assert_eq ! (unsafe { :: std :: ptr :: addr_of ! ((* ptr) . _lock) as usize - ptr as usize } , 136usize , concat ! ("Offset of field: " , stringify ! (_IO_FILE) , "::" , stringify ! (_lock))) ; assert_eq ! (unsafe { :: std :: ptr :: addr_of ! ((* ptr) . _offset) as usize - ptr as usize } , 144usize , concat ! ("Offset of field: " , stringify ! (_IO_FILE) , "::" , stringify ! (_offset))) ; assert_eq ! (unsafe { :: std :: ptr :: addr_of ! ((* ptr) . _codecvt) as usize - ptr as usize } , 152usize , concat ! ("Offset of field: " , stringify ! (_IO_FILE) , "::" , stringify ! (_codecvt))) ; assert_eq ! (unsafe { :: std :: ptr :: addr_of ! ((* ptr) . _wide_data) as usize - ptr as usize } , 160usize , concat ! ("Offset of field: " , stringify ! (_IO_FILE) , "::" , stringify ! (_wide_data))) ; assert_eq ! (unsafe { :: std :: ptr :: addr_of ! ((* ptr) . _freeres_list) as usize - ptr as usize } , 168usize , concat ! ("Offset of field: " , stringify ! (_IO_FILE) , "::" , stringify ! (_freeres_list))) ; assert_eq ! (unsafe { :: std :: ptr :: addr_of ! ((* ptr) . _freeres_buf) as usize - ptr as usize } , 176usize , concat ! ("Offset of field: " , stringify ! (_IO_FILE) , "::" , stringify ! (_freeres_buf))) ; assert_eq ! (unsafe { :: std :: ptr :: addr_of ! ((* ptr) . __pad5) as usize - ptr as usize } , 184usize , concat ! ("Offset of field: " , stringify ! (_IO_FILE) , "::" , stringify ! (__pad5))) ; assert_eq ! (unsafe { :: std :: ptr :: addr_of ! ((* ptr) . _mode) as usize - ptr as usize } , 192usize , concat ! ("Offset of field: " , stringify ! (_IO_FILE) , "::" , stringify ! (_mode))) ; assert_eq ! (unsafe { :: std :: ptr :: addr_of ! ((* ptr) . _unused2) as usize - ptr as usize } , 196usize , concat ! ("Offset of field: " , stringify ! (_IO_FILE) , "::" , stringify ! (_unused2))) ; } pub type yamm_ns_uint_64_t = :: std :: os :: raw :: c_ulonglong ; # [doc = " Class that models a basic access which requires a start address and a size\n End address is computed automatically"] # [repr (C)] # [derive (Debug , Copy , Clone)] pub struct yamm_ns_yamm_access { # [doc = " Start address of the access. Given by user"] pub start_addr : yamm_ns_uint_64_t , # [doc = " End address of the access. Computed automatically"] pub end_addr : yamm_ns_uint_64_t , # [doc = " Size of the access. Given by user"] pub size : yamm_ns_uint_64_t , } # [test] fn bindgen_test_layout_yamm_ns_yamm_access () { const UNINIT : :: std :: mem :: MaybeUninit < yamm_ns_yamm_access > = :: std :: mem :: MaybeUninit :: uninit () ; let ptr = UNINIT . as_ptr () ; assert_eq ! (:: std :: mem :: size_of :: < yamm_ns_yamm_access > () , 24usize , concat ! ("Size of: " , stringify ! (yamm_ns_yamm_access))) ; assert_eq ! (:: std :: mem :: align_of :: < yamm_ns_yamm_access > () , 8usize , concat ! ("Alignment of " , stringify ! (yamm_ns_yamm_access))) ; assert_eq ! (unsafe { :: std :: ptr :: addr_of ! ((* ptr) . start_addr) as usize - ptr as usize } , 0usize , concat ! ("Offset of field: " , stringify ! (yamm_ns_yamm_access) , "::" , stringify ! (start_addr))) ; assert_eq ! (unsafe { :: std :: ptr :: addr_of ! ((* ptr) . end_addr) as usize - ptr as usize } , 8usize , concat ! ("Offset of field: " , stringify ! (yamm_ns_yamm_access) , "::" , stringify ! (end_addr))) ; assert_eq ! (unsafe { :: std :: ptr :: addr_of ! ((* ptr) . size) as usize - ptr as usize } , 16usize , concat ! ("Offset of field: " , stringify ! (yamm_ns_yamm_access) , "::" , stringify ! (size))) ; } pub type yamm_ns_uint_32_t = :: std :: os :: raw :: c_uint ; # [repr (C)] pub struct yamm_ns_yamm_buffer__bindgen_vtable (:: std :: os :: raw :: c_void) ; # [doc = " Class that defines a buffer"] # [repr (C)] pub struct yamm_ns_yamm_buffer { pub vtable_ : * const yamm_ns_yamm_buffer__bindgen_vtable , # [doc = " first free buffer contained"] pub first_free : * mut yamm_ns_yamm_buffer , # [doc = " first buffer contained (free or occupied)"] pub first : * mut yamm_ns_yamm_buffer , # [doc = " next free buffer on current recursion level"] pub next_free : * mut yamm_ns_yamm_buffer , # [doc = " previous free buffer on current recursion level"] pub prev_free : * mut yamm_ns_yamm_buffer , # [doc = " next buffer on current recursion level (free or occupied)"] pub next : * mut yamm_ns_yamm_buffer , # [doc = " previous free buffer on current recursion level (free or occupied)"] pub prev : * mut yamm_ns_yamm_buffer , # [doc = " buffer's payload"] pub contents : * mut :: std :: os :: raw :: c_char , # [doc = " number of occupied buffers"] pub number_of_buffers : uint , # [doc = " number of free buffers"] pub number_of_free_buffers : uint , # [doc = " Start address of the buffer"] pub start_addr : yamm_ns_uint_64_t , # [doc = " End address of the buffer"] pub end_addr : yamm_ns_uint_64_t , # [doc = " Size of the buffer"] pub size : yamm_ns_uint_64_t , # [doc = " Granularity of the buffer"] pub granularity : yamm_ns_uint_32_t , # [doc = " Alignment of the buffer"] pub start_addr_alignment : yamm_ns_uint_32_t , # [doc = " Buffer is not occupied"] pub is_free : bool , # [doc = " Buffer is allocated in static mode"] pub is_static : bool , # [doc = " Name given by user"] pub name : std_string , # [doc = " 0 by default. If set to 1 no YAMM_WRN will be shown"] pub disable_warnings : bool , # [doc = " 0 by default. If set to 1 no YAMM_INF will be shown"] pub disable_info : bool , } # [test] fn bindgen_test_layout_yamm_ns_yamm_buffer () { const UNINIT : :: std :: mem :: MaybeUninit < yamm_ns_yamm_buffer > = :: std :: mem :: MaybeUninit :: uninit () ; let ptr = UNINIT . as_ptr () ; assert_eq ! (:: std :: mem :: size_of :: < yamm_ns_yamm_buffer > () , 152usize , concat ! ("Size of: " , stringify ! (yamm_ns_yamm_buffer))) ; assert_eq ! (:: std :: mem :: align_of :: < yamm_ns_yamm_buffer > () , 8usize , concat ! ("Alignment of " , stringify ! (yamm_ns_yamm_buffer))) ; assert_eq ! (unsafe { :: std :: ptr :: addr_of ! ((* ptr) . first_free) as usize - ptr as usize } , 8usize , concat ! ("Offset of field: " , stringify ! (yamm_ns_yamm_buffer) , "::" , stringify ! (first_free))) ; assert_eq ! (unsafe { :: std :: ptr :: addr_of ! ((* ptr) . first) as usize - ptr as usize } , 16usize , concat ! ("Offset of field: " , stringify ! (yamm_ns_yamm_buffer) , "::" , stringify ! (first))) ; assert_eq ! (unsafe { :: std :: ptr :: addr_of ! ((* ptr) . next_free) as usize - ptr as usize } , 24usize , concat ! ("Offset of field: " , stringify ! (yamm_ns_yamm_buffer) , "::" , stringify ! (next_free))) ; assert_eq ! (unsafe { :: std :: ptr :: addr_of ! ((* ptr) . prev_free) as usize - ptr as usize } , 32usize , concat ! ("Offset of field: " , stringify ! (yamm_ns_yamm_buffer) , "::" , stringify ! (prev_free))) ; assert_eq ! (unsafe { :: std :: ptr :: addr_of ! ((* ptr) . next) as usize - ptr as usize } , 40usize , concat ! ("Offset of field: " , stringify ! (yamm_ns_yamm_buffer) , "::" , stringify ! (next))) ; assert_eq ! (unsafe { :: std :: ptr :: addr_of ! ((* ptr) . prev) as usize - ptr as usize } , 48usize , concat ! ("Offset of field: " , stringify ! (yamm_ns_yamm_buffer) , "::" , stringify ! (prev))) ; assert_eq ! (unsafe { :: std :: ptr :: addr_of ! ((* ptr) . contents) as usize - ptr as usize } , 56usize , concat ! ("Offset of field: " , stringify ! (yamm_ns_yamm_buffer) , "::" , stringify ! (contents))) ; assert_eq ! (unsafe { :: std :: ptr :: addr_of ! ((* ptr) . number_of_buffers) as usize - ptr as usize } , 64usize , concat ! ("Offset of field: " , stringify ! (yamm_ns_yamm_buffer) , "::" , stringify ! (number_of_buffers))) ; assert_eq ! (unsafe { :: std :: ptr :: addr_of ! ((* ptr) . number_of_free_buffers) as usize - ptr as usize } , 68usize , concat ! ("Offset of field: " , stringify ! (yamm_ns_yamm_buffer) , "::" , stringify ! (number_of_free_buffers))) ; assert_eq ! (unsafe { :: std :: ptr :: addr_of ! ((* ptr) . start_addr) as usize - ptr as usize } , 72usize , concat ! ("Offset of field: " , stringify ! (yamm_ns_yamm_buffer) , "::" , stringify ! (start_addr))) ; assert_eq ! (unsafe { :: std :: ptr :: addr_of ! ((* ptr) . end_addr) as usize - ptr as usize } , 80usize , concat ! ("Offset of field: " , stringify ! (yamm_ns_yamm_buffer) , "::" , stringify ! (end_addr))) ; assert_eq ! (unsafe { :: std :: ptr :: addr_of ! ((* ptr) . size) as usize - ptr as usize } , 88usize , concat ! ("Offset of field: " , stringify ! (yamm_ns_yamm_buffer) , "::" , stringify ! (size))) ; assert_eq ! (unsafe { :: std :: ptr :: addr_of ! ((* ptr) . granularity) as usize - ptr as usize } , 96usize , concat ! ("Offset of field: " , stringify ! (yamm_ns_yamm_buffer) , "::" , stringify ! (granularity))) ; assert_eq ! (unsafe { :: std :: ptr :: addr_of ! ((* ptr) . start_addr_alignment) as usize - ptr as usize } , 100usize , concat ! ("Offset of field: " , stringify ! (yamm_ns_yamm_buffer) , "::" , stringify ! (start_addr_alignment))) ; assert_eq ! (unsafe { :: std :: ptr :: addr_of ! ((* ptr) . is_free) as usize - ptr as usize } , 104usize , concat ! ("Offset of field: " , stringify ! (yamm_ns_yamm_buffer) , "::" , stringify ! (is_free))) ; assert_eq ! (unsafe { :: std :: ptr :: addr_of ! ((* ptr) . is_static) as usize - ptr as usize } , 105usize , concat ! ("Offset of field: " , stringify ! (yamm_ns_yamm_buffer) , "::" , stringify ! (is_static))) ; assert_eq ! (unsafe { :: std :: ptr :: addr_of ! ((* ptr) . name) as usize - ptr as usize } , 112usize , concat ! ("Offset of field: " , stringify ! (yamm_ns_yamm_buffer) , "::" , stringify ! (name))) ; assert_eq ! (unsafe { :: std :: ptr :: addr_of ! ((* ptr) . disable_warnings) as usize - ptr as usize } , 144usize , concat ! ("Offset of field: " , stringify ! (yamm_ns_yamm_buffer) , "::" , stringify ! (disable_warnings))) ; assert_eq ! (unsafe { :: std :: ptr :: addr_of ! ((* ptr) . disable_info) as usize - ptr as usize } , 145usize , concat ! ("Offset of field: " , stringify ! (yamm_ns_yamm_buffer) , "::" , stringify ! (disable_info))) ; } extern "C" { # [doc = " Generates a random unsigned int64\n @return random unsigned int64"] # [link_name = "\u{1}_ZN7yamm_ns11yamm_buffer15generate_rand64Ev"] pub fn yamm_ns_yamm_buffer_generate_rand64 (this : * mut yamm_ns_yamm_buffer) -> yamm_ns_uint_64_t ; } extern "C" { # [doc = " Used to compute start_addr with alignment, only works for positive increment\n Used by allocate() and insert()\n\n @param alignment The alignment needed\n @param free_buffer Free buffer in which the allocation takes place, used for boundaries checking\n\n @return Aligned start_addr if boundaries checking passes or temp buffer's (end_addr+1) if not"] # [link_name = "\u{1}_ZN7yamm_ns11yamm_buffer16get_aligned_addrERKjPS0_"] pub fn yamm_ns_yamm_buffer_get_aligned_addr (this : * mut yamm_ns_yamm_buffer , alignment : * const yamm_ns_uint_32_t , free_buffer : * mut yamm_ns_yamm_buffer) -> yamm_ns_uint_64_t ; } extern "C" { # [doc = " Computes the size taking in account alignment using get_aligned_addr()\n Used by find_suitable_buffer()\n\n @param alignment The regular size of the buffer\n @param temp The granularity of the buffer\n\n @return The new size taking in account the granularity"] # [link_name = "\u{1}_ZN7yamm_ns11yamm_buffer23compute_size_with_alignERKjPS0_"] pub fn yamm_ns_yamm_buffer_compute_size_with_align (this : * mut yamm_ns_yamm_buffer , alignment : * const yamm_ns_uint_32_t , temp : * mut yamm_ns_yamm_buffer) -> yamm_ns_uint_64_t ; } extern "C" { # [doc = " Computes and returns the size of the buffer on which it is called\n Used by allocate()\n\n @param size The regular size of the buffer\n @param granularity The granularity of the buffer\n\n @return The new size taking in account the granularity"] # [link_name = "\u{1}_ZN7yamm_ns11yamm_buffer22compute_size_with_granEyj"] pub fn yamm_ns_yamm_buffer_compute_size_with_gran (this : * mut yamm_ns_yamm_buffer , size : yamm_ns_uint_64_t , granularity : yamm_ns_uint_32_t) -> yamm_ns_uint_64_t ; } extern "C" { # [doc = " It computes and updates start_addr for various allocation modes, uses get_aligned_addr() and get_closest_aligned_addr()\n Used by allocate()\n\n @param temp The buffer in which the allocation takes place, used to set boundaries\n @param alloc_mode Allocation mode that dictates how the alignment is applied\n\n @return 1 if success , 0 otherwise"] # [link_name = "\u{1}_ZN7yamm_ns11yamm_buffer18compute_start_addrEPS0_i"] pub fn yamm_ns_yamm_buffer_compute_start_addr (this : * mut yamm_ns_yamm_buffer , temp : * mut yamm_ns_yamm_buffer , alloc_mode : :: std :: os :: raw :: c_int) -> bool ; } extern "C" { # [doc = " It automatically updates the start_addr taking in account the alignment\n It can modify the start_addr both by adding to it or subtracting from it\n Used by compute_size_with_align()\n\n @param temp The buffer in which the allocation takes place, usable for boundaries checking"] # [link_name = "\u{1}_ZN7yamm_ns11yamm_buffer24get_closest_aligned_addrEPS0_"] pub fn yamm_ns_yamm_buffer_get_closest_aligned_addr (this : * mut yamm_ns_yamm_buffer , temp : * mut yamm_ns_yamm_buffer) ; } extern "C" { # [doc = " It adds buffer n inside free buffer temp, it calls link_in_list to update the pointers\n\n @param buffer_to_fit The new buffer that will be added to the memory\n @param place The free buffer found by find_suitable_buffer() in which n is going to be allocated"] # [link_name = "\u{1}_ZN7yamm_ns11yamm_buffer3addEPS0_S1_"] pub fn yamm_ns_yamm_buffer_add (this : * mut yamm_ns_yamm_buffer , buffer_to_fit : * mut yamm_ns_yamm_buffer , place : * mut yamm_ns_yamm_buffer) ; } extern "C" { # [doc = " It links buffers in memory after adding a new buffer\n\n @param temp_prev The free buffer created from the start of the old free buffer that spans to the start of the new buffer, can be NULL\n @param n The new buffer that was just allocated\n @param temp The old buffer that was resized, if the end address of the new buffer matches its end address then it won't get linked"] # [link_name = "\u{1}_ZN7yamm_ns11yamm_buffer12link_in_listEPS0_S1_S1_"] pub fn yamm_ns_yamm_buffer_link_in_list (this : * mut yamm_ns_yamm_buffer , temp_prev : * mut yamm_ns_yamm_buffer , n : * mut yamm_ns_yamm_buffer , temp : * mut yamm_ns_yamm_buffer) ; } extern "C" { # [doc = " It merges free buffers after deallocation\n\n @param free_n The buffer that was deallocated, it is going to get merged with neighboring buffers if they are free"] # [link_name = "\u{1}_ZN7yamm_ns11yamm_buffer5mergeEPS0_"] pub fn yamm_ns_yamm_buffer_merge (this : * mut yamm_ns_yamm_buffer , free_n : * mut yamm_ns_yamm_buffer) ; } extern "C" { # [doc = " Used for finding a suitable buffer in which the new buffer can be allocated\n Used by compute_size_with_align() and insert()\n\n @param size The size of the new buffer\n @param alignment The alignment of the new buffer\n @param alloc_mode The allocation mode, dictates the search rules\n\n @return A suitable free buffer if it exists or NULL otherwise"] # [link_name = "\u{1}_ZN7yamm_ns11yamm_buffer20find_suitable_bufferEyji"] pub fn yamm_ns_yamm_buffer_find_suitable_buffer (this : * mut yamm_ns_yamm_buffer , size : yamm_ns_uint_64_t , alignment : yamm_ns_uint_32_t , alloc_mode : :: std :: os :: raw :: c_int) -> * mut yamm_ns_yamm_buffer ; } extern "C" { # [doc = " Same as get_buffer() but it can also return free buffer, used internally.\n\n @param address The address for which the search is executed\n\n @return Returns the buffer which contains the specified address. It returns a NULL handle if no buffer exists at the specfied address"] # [link_name = "\u{1}_ZN7yamm_ns11yamm_buffer19internal_get_bufferEy"] pub fn yamm_ns_yamm_buffer_internal_get_buffer (this : * mut yamm_ns_yamm_buffer , address : yamm_ns_uint_64_t) -> * mut yamm_ns_yamm_buffer ; } extern "C" { # [doc = " Function that traverses the entire memory printing each buffer's number, size, start and end address.\n @param fp Pointer to the file you want to dump the memory to"] # [link_name = "\u{1}_ZN7yamm_ns11yamm_buffer5printEP8_IO_FILE"] pub fn yamm_ns_yamm_buffer_print (this : * mut yamm_ns_yamm_buffer , fp : * mut FILE) ; } extern "C" { # [doc = " Function that traverses the FREE memory printing each buffer's number, size, start and end address.\n @param fp Pointer to the file you want to dump the memory to"] # [link_name = "\u{1}_ZN7yamm_ns11yamm_buffer10print_freeEP8_IO_FILE"] pub fn yamm_ns_yamm_buffer_print_free (this : * mut yamm_ns_yamm_buffer , fp : * mut FILE) ; } extern "C" { # [doc = "\tFunction that prints the size argument according to it's size (Gb,Mb,Kb,bytes).\n\n\t@return Buffer's size"] # [link_name = "\u{1}_ZN7yamm_ns11yamm_buffer10print_sizeB5cxx11Ev"] pub fn yamm_ns_yamm_buffer_print_size (this : * mut yamm_ns_yamm_buffer) -> std_string ; } extern "C" { # [doc = " Removes all buffers that are not static."] # [link_name = "\u{1}_ZN7yamm_ns11yamm_buffer10soft_resetEv"] pub fn yamm_ns_yamm_buffer_soft_reset (this : * mut yamm_ns_yamm_buffer) ; } extern "C" { # [doc = " Function that deallocates all (including static) buffers."] # [link_name = "\u{1}_ZN7yamm_ns11yamm_buffer10hard_resetEv"] pub fn yamm_ns_yamm_buffer_hard_reset (this : * mut yamm_ns_yamm_buffer) ; } extern "C" { # [doc = " This function tries to allocate the buffer in the memory, according to\n the allocation_mode\n\n The buffer argument handle is required to contain a valid size (bigger than zero)\n\n @param new_buffer The new buffer that is going to get allocated\n @param allocation_mode The allocation mode according to which the allocation will be done\n\n @return It returns 1 if the buffer was successfully allocated or 0 otherwise. It returns 0 if there is no free space for the buffer to be allocated.\n On successful allocation, the buffer handle is updated with additional information: start_addr, end_addr"] # [link_name = "\u{1}_ZN7yamm_ns11yamm_buffer8allocateEPS0_i"] pub fn yamm_ns_yamm_buffer_allocate (this : * mut yamm_ns_yamm_buffer , new_buffer : * mut yamm_ns_yamm_buffer , allocation_mode : :: std :: os :: raw :: c_int) -> bool ; } extern "C" { # [doc = " This function tries to allocate a buffer with the specified size in the memory,\n according to allocation_mode.\n\n Function creates a new buffer with that size and calls allocate()\n\n @param size The size of the new buffer\n @param allocation_mode The allocation mode according to which the allocation will be done\n\n @return It returns a buffer handle if successful or a null handle otherwise"] # [link_name = "\u{1}_ZN7yamm_ns11yamm_buffer16allocate_by_sizeEyi"] pub fn yamm_ns_yamm_buffer_allocate_by_size (this : * mut yamm_ns_yamm_buffer , size : yamm_ns_uint_64_t , allocation_mode : :: std :: os :: raw :: c_int) -> * mut yamm_ns_yamm_buffer ; } extern "C" { # [doc = " This function tries to insert a buffer in the memory with the specified start_addr and size.\n The function makes use of the field size and the start_addr contained in the specified buffer.\n\n @param new_buffer The new buffer that is going to be inserted\n\n @return It returns 1 if the operation is successful or 0 if the buffer would collide with another buffer in the memory.\n"] # [link_name = "\u{1}_ZN7yamm_ns11yamm_buffer6insertEPS0_"] pub fn yamm_ns_yamm_buffer_insert (this : * mut yamm_ns_yamm_buffer , new_buffer : * mut yamm_ns_yamm_buffer) -> bool ; } extern "C" { # [doc = " Similar to insert(), this function will try to insert a buffer at a specified address in memory,\n but it takes an access as an argument instead of a buffer.\n\n @param access The access from which the buffer is created\n\n @return It returns the allocated buffer handle if the operation is successful or a null handle otherwise.\n"] # [link_name = "\u{1}_ZN7yamm_ns11yamm_buffer13insert_accessEPNS_11yamm_accessE"] pub fn yamm_ns_yamm_buffer_insert_access (this : * mut yamm_ns_yamm_buffer , access : * mut yamm_ns_yamm_access) -> * mut yamm_ns_yamm_buffer ; } extern "C" { # [doc = " Function that wipes the data stored in the buffer"] # [link_name = "\u{1}_ZN7yamm_ns11yamm_buffer14reset_contentsEv"] pub fn yamm_ns_yamm_buffer_reset_contents (this : * mut yamm_ns_yamm_buffer) ; } extern "C" { # [doc = " This function tries to deallocate a buffer allocated in the memory.\n\n A warning is given if the buffer contains other buffers inside.\n\n @param buffer The buffer that is going to be deallocated\n\n @return It returns 1 if successful. It returns 0 if the specified buffer can’t be found or is a static buffer."] # [link_name = "\u{1}_ZN7yamm_ns11yamm_buffer10deallocateEPS0_"] pub fn yamm_ns_yamm_buffer_deallocate (this : * mut yamm_ns_yamm_buffer , buffer : * mut yamm_ns_yamm_buffer) -> bool ; } extern "C" { # [doc = " This function tries to deallocate from the memory the buffer which\n contains the specified address.\n\n A warning is given if the buffer contains other buffers inside.\n\n @param address The address at which the buffer that is going to get deallocated resides.\n\n @return It returns 1 if successful. It returns 0 if the specified buffer can’t be found or is a static buffer."] # [link_name = "\u{1}_ZN7yamm_ns11yamm_buffer18deallocate_by_addrEy"] pub fn yamm_ns_yamm_buffer_deallocate_by_addr (this : * mut yamm_ns_yamm_buffer , address : yamm_ns_uint_64_t) -> bool ; } extern "C" { # [doc = " It searches for the buffer located at the specified address.\n\n @param address The address for which the search is executed\n\n @return Returns the buffer which contains the specified address. It returns a NULL handle if no buffer used exists at the specfied address"] # [link_name = "\u{1}_ZN7yamm_ns11yamm_buffer10get_bufferEy"] pub fn yamm_ns_yamm_buffer_get_buffer (this : * mut yamm_ns_yamm_buffer , address : yamm_ns_uint_64_t) -> * mut yamm_ns_yamm_buffer ; } extern "C" { # [doc = " It searches for all buffers that span in the address space defined by start_addr and end_addr.\n\n @param start_addr The start address of the memory span on which the search is done\n @param end_addr The end address of the memory span on which the search is done\n\n @return Returns a vector of buffers. If end_addr is less than start_addr or no buffers used are found it will return an empty queue."] # [link_name = "\u{1}_ZN7yamm_ns11yamm_buffer20get_buffers_in_rangeEyy"] pub fn yamm_ns_yamm_buffer_get_buffers_in_range (this : * mut yamm_ns_yamm_buffer , start_addr : yamm_ns_uint_64_t , end_addr : yamm_ns_uint_64_t) -> std_vector ; } extern "C" { # [doc = " It searches for all buffers that span in the address range specified by access.\n The address range is computed using start_addr and size fields of yamm_access.\n\n @param access The access from which the search parameters are extracted\n\n @return It returns a queue of buffers. If no buffers are found, it will return an empty queue."] # [link_name = "\u{1}_ZN7yamm_ns11yamm_buffer21get_buffers_by_accessEPNS_11yamm_accessE"] pub fn yamm_ns_yamm_buffer_get_buffers_by_access (this : * mut yamm_ns_yamm_buffer , access : * mut yamm_ns_yamm_access) -> std_vector ; } extern "C" { # [doc = " Searches by the name given to the buffers\n\n @param name_to_find The name for which the search is done\n\n @return Function returns a queue with all buffers of a certain kind."] # [link_name = "\u{1}_ZN7yamm_ns11yamm_buffer19get_buffers_by_nameENSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE"] pub fn yamm_ns_yamm_buffer_get_buffers_by_name (this : * mut yamm_ns_yamm_buffer , name_to_find : std_string) -> std_vector ; } extern "C" { # [link_name = "\u{1}_ZN7yamm_ns11yamm_buffer15access_overlapsEPNS_11yamm_accessE"] pub fn yamm_ns_yamm_buffer_access_overlaps (this : * mut yamm_ns_yamm_buffer , access : * mut yamm_ns_yamm_access) -> bool ; } extern "C" { # [doc = " Returns the memory structure as a string.\n\n\t@param recursive If set to 1 it will print the memory recursive\n\t@param indentation Used when going in recursion\n\n\t@return The memory structure as a string"] # [link_name = "\u{1}_ZN7yamm_ns11yamm_buffer6sprintB5cxx11Ebi"] pub fn yamm_ns_yamm_buffer_sprint (this : * mut yamm_ns_yamm_buffer , recursive : bool , indentation : :: std :: os :: raw :: c_int) -> std_string ; } extern "C" { # [doc = " Writes the memory structure to file\n\n @param filename Path to the file"] # [link_name = "\u{1}_ZN7yamm_ns11yamm_buffer13write_to_fileENSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE"] pub fn yamm_ns_yamm_buffer_write_to_file (this : * mut yamm_ns_yamm_buffer , filename : std_string) ; } extern "C" { # [doc = " Returns the percentage of fragmentation"] # [link_name = "\u{1}_ZN7yamm_ns11yamm_buffer17get_fragmentationEv"] pub fn yamm_ns_yamm_buffer_get_fragmentation (this : * mut yamm_ns_yamm_buffer) -> f64 ; } extern "C" { # [doc = " Returns the percentage of free memory compared to the whole memory."] # [link_name = "\u{1}_ZN7yamm_ns11yamm_buffer20get_usage_statisticsEv"] pub fn yamm_ns_yamm_buffer_get_usage_statistics (this : * mut yamm_ns_yamm_buffer) -> f64 ; } extern "C" { # [doc = " This function is used to do a self-check on the memory model to see if all\n the buffers are correctly allocated by the model.\n It will trigger an error message if any inconsistency is found.\n It is used for debug purposes.\n\n @return Returns 1 if no errors are found and 0 otherwise."] # [link_name = "\u{1}_ZN7yamm_ns11yamm_buffer31check_address_space_consistencyEv"] pub fn yamm_ns_yamm_buffer_check_address_space_consistency (this : * mut yamm_ns_yamm_buffer) -> bool ; } extern "C" { # [doc = " All fields are set to the default value"] # [link_name = "\u{1}_ZN7yamm_ns11yamm_bufferC1Ev"] pub fn yamm_ns_yamm_buffer_yamm_buffer (this : * mut yamm_ns_yamm_buffer) ; } extern "C" { # [doc = " Just size is set. WARNING start_addr == end_addr == 0!"] # [link_name = "\u{1}_ZN7yamm_ns11yamm_bufferC1Ey"] pub fn yamm_ns_yamm_buffer_yamm_buffer1 (this : * mut yamm_ns_yamm_buffer , size : yamm_ns_uint_64_t) ; } extern "C" { # [doc = " Set the start and end address. Size is computed automatically"] # [link_name = "\u{1}_ZN7yamm_ns11yamm_bufferC1Eyy"] pub fn yamm_ns_yamm_buffer_yamm_buffer2 (this : * mut yamm_ns_yamm_buffer , start : yamm_ns_uint_64_t , size : yamm_ns_uint_64_t) ; } extern "C" { # [doc = " Just the name"] # [link_name = "\u{1}_ZN7yamm_ns11yamm_bufferC1ENSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE"] pub fn yamm_ns_yamm_buffer_yamm_buffer3 (this : * mut yamm_ns_yamm_buffer , name : std_string) ; } extern "C" { # [doc = " Size + name"] # [link_name = "\u{1}_ZN7yamm_ns11yamm_bufferC1EyNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE"] pub fn yamm_ns_yamm_buffer_yamm_buffer4 (this : * mut yamm_ns_yamm_buffer , size : yamm_ns_uint_64_t , name : std_string) ; } extern "C" { # [doc = " All fields will be identical to the buffer given as argument"] # [link_name = "\u{1}_ZN7yamm_ns11yamm_bufferC1EPS0_"] pub fn yamm_ns_yamm_buffer_yamm_buffer5 (this : * mut yamm_ns_yamm_buffer , new_buffer : * mut yamm_ns_yamm_buffer) ; } impl yamm_ns_yamm_buffer { # [inline] pub unsafe fn generate_rand64 (& mut self) -> yamm_ns_uint_64_t { yamm_ns_yamm_buffer_generate_rand64 (self) } # [inline] pub unsafe fn get_aligned_addr (& mut self , alignment : * const yamm_ns_uint_32_t , free_buffer : * mut yamm_ns_yamm_buffer) -> yamm_ns_uint_64_t { yamm_ns_yamm_buffer_get_aligned_addr (self , alignment , free_buffer) } # [inline] pub unsafe fn compute_size_with_align (& mut self , alignment : * const yamm_ns_uint_32_t , temp : * mut yamm_ns_yamm_buffer) -> yamm_ns_uint_64_t { yamm_ns_yamm_buffer_compute_size_with_align (self , alignment , temp) } # [inline] pub unsafe fn compute_size_with_gran (& mut self , size : yamm_ns_uint_64_t , granularity : yamm_ns_uint_32_t) -> yamm_ns_uint_64_t { yamm_ns_yamm_buffer_compute_size_with_gran (self , size , granularity) } # [inline] pub unsafe fn compute_start_addr (& mut self , temp : * mut yamm_ns_yamm_buffer , alloc_mode : :: std :: os :: raw :: c_int) -> bool { yamm_ns_yamm_buffer_compute_start_addr (self , temp , alloc_mode) } # [inline] pub unsafe fn get_closest_aligned_addr (& mut self , temp : * mut yamm_ns_yamm_buffer) { yamm_ns_yamm_buffer_get_closest_aligned_addr (self , temp) } # [inline] pub unsafe fn add (& mut self , buffer_to_fit : * mut yamm_ns_yamm_buffer , place : * mut yamm_ns_yamm_buffer) { yamm_ns_yamm_buffer_add (self , buffer_to_fit , place) } # [inline] pub unsafe fn link_in_list (& mut self , temp_prev : * mut yamm_ns_yamm_buffer , n : * mut yamm_ns_yamm_buffer , temp : * mut yamm_ns_yamm_buffer) { yamm_ns_yamm_buffer_link_in_list (self , temp_prev , n , temp) } # [inline] pub unsafe fn merge (& mut self , free_n : * mut yamm_ns_yamm_buffer) { yamm_ns_yamm_buffer_merge (self , free_n) } # [inline] pub unsafe fn find_suitable_buffer (& mut self , size : yamm_ns_uint_64_t , alignment : yamm_ns_uint_32_t , alloc_mode : :: std :: os :: raw :: c_int) -> * mut yamm_ns_yamm_buffer { yamm_ns_yamm_buffer_find_suitable_buffer (self , size , alignment , alloc_mode) } # [inline] pub unsafe fn internal_get_buffer (& mut self , address : yamm_ns_uint_64_t) -> * mut yamm_ns_yamm_buffer { yamm_ns_yamm_buffer_internal_get_buffer (self , address) } # [inline] pub unsafe fn print (& mut self , fp : * mut FILE) { yamm_ns_yamm_buffer_print (self , fp) } # [inline] pub unsafe fn print_free (& mut self , fp : * mut FILE) { yamm_ns_yamm_buffer_print_free (self , fp) } # [inline] pub unsafe fn print_size (& mut self) -> std_string { yamm_ns_yamm_buffer_print_size (self) } # [inline] pub unsafe fn soft_reset (& mut self) { yamm_ns_yamm_buffer_soft_reset (self) } # [inline] pub unsafe fn hard_reset (& mut self) { yamm_ns_yamm_buffer_hard_reset (self) } # [inline] pub unsafe fn allocate (& mut self , new_buffer : * mut yamm_ns_yamm_buffer , allocation_mode : :: std :: os :: raw :: c_int) -> bool { yamm_ns_yamm_buffer_allocate (self , new_buffer , allocation_mode) } # [inline] pub unsafe fn allocate_by_size (& mut self , size : yamm_ns_uint_64_t , allocation_mode : :: std :: os :: raw :: c_int) -> * mut yamm_ns_yamm_buffer { yamm_ns_yamm_buffer_allocate_by_size (self , size , allocation_mode) } # [inline] pub unsafe fn insert (& mut self , new_buffer : * mut yamm_ns_yamm_buffer) -> bool { yamm_ns_yamm_buffer_insert (self , new_buffer) } # [inline] pub unsafe fn insert_access (& mut self , access : * mut yamm_ns_yamm_access) -> * mut yamm_ns_yamm_buffer { yamm_ns_yamm_buffer_insert_access (self , access) } # [inline] pub unsafe fn reset_contents (& mut self) { yamm_ns_yamm_buffer_reset_contents (self) } # [inline] pub unsafe fn deallocate (& mut self , buffer : * mut yamm_ns_yamm_buffer) -> bool { yamm_ns_yamm_buffer_deallocate (self , buffer) } # [inline] pub unsafe fn deallocate_by_addr (& mut self , address : yamm_ns_uint_64_t) -> bool { yamm_ns_yamm_buffer_deallocate_by_addr (self , address) } # [inline] pub unsafe fn get_buffer (& mut self , address : yamm_ns_uint_64_t) -> * mut yamm_ns_yamm_buffer { yamm_ns_yamm_buffer_get_buffer (self , address) } # [inline] pub unsafe fn get_buffers_in_range (& mut self , start_addr : yamm_ns_uint_64_t , end_addr : yamm_ns_uint_64_t) -> std_vector { yamm_ns_yamm_buffer_get_buffers_in_range (self , start_addr , end_addr) } # [inline] pub unsafe fn get_buffers_by_access (& mut self , access : * mut yamm_ns_yamm_access) -> std_vector { yamm_ns_yamm_buffer_get_buffers_by_access (self , access) } # [inline] pub unsafe fn get_buffers_by_name (& mut self , name_to_find : std_string) -> std_vector { yamm_ns_yamm_buffer_get_buffers_by_name (self , name_to_find) } # [inline] pub unsafe fn access_overlaps (& mut self , access : * mut yamm_ns_yamm_access) -> bool { yamm_ns_yamm_buffer_access_overlaps (self , access) } # [inline] pub unsafe fn sprint (& mut self , recursive : bool , indentation : :: std :: os :: raw :: c_int) -> std_string { yamm_ns_yamm_buffer_sprint (self , recursive , indentation) } # [inline] pub unsafe fn write_to_file (& mut self , filename : std_string) { yamm_ns_yamm_buffer_write_to_file (self , filename) } # [inline] pub unsafe fn get_fragmentation (& mut self) -> f64 { yamm_ns_yamm_buffer_get_fragmentation (self) } # [inline] pub unsafe fn get_usage_statistics (& mut self) -> f64 { yamm_ns_yamm_buffer_get_usage_statistics (self) } # [inline] pub unsafe fn check_address_space_consistency (& mut self) -> bool { yamm_ns_yamm_buffer_check_address_space_consistency (self) } # [inline] pub unsafe fn new () -> Self { let mut __bindgen_tmp = :: std :: mem :: MaybeUninit :: uninit () ; yamm_ns_yamm_buffer_yamm_buffer (__bindgen_tmp . as_mut_ptr ()) ; __bindgen_tmp . assume_init () } # [inline] pub unsafe fn new1 (size : yamm_ns_uint_64_t) -> Self { let mut __bindgen_tmp = :: std :: mem :: MaybeUninit :: uninit () ; yamm_ns_yamm_buffer_yamm_buffer1 (__bindgen_tmp . as_mut_ptr () , size) ; __bindgen_tmp . assume_init () } # [inline] pub unsafe fn new2 (start : yamm_ns_uint_64_t , size : yamm_ns_uint_64_t) -> Self { let mut __bindgen_tmp = :: std :: mem :: MaybeUninit :: uninit () ; yamm_ns_yamm_buffer_yamm_buffer2 (__bindgen_tmp . as_mut_ptr () , start , size) ; __bindgen_tmp . assume_init () } # [inline] pub unsafe fn new3 (name : std_string) -> Self { let mut __bindgen_tmp = :: std :: mem :: MaybeUninit :: uninit () ; yamm_ns_yamm_buffer_yamm_buffer3 (__bindgen_tmp . as_mut_ptr () , name) ; __bindgen_tmp . assume_init () } # [inline] pub unsafe fn new4 (size : yamm_ns_uint_64_t , name : std_string) -> Self { let mut __bindgen_tmp = :: std :: mem :: MaybeUninit :: uninit () ; yamm_ns_yamm_buffer_yamm_buffer4 (__bindgen_tmp . as_mut_ptr () , size , name) ; __bindgen_tmp . assume_init () } # [inline] pub unsafe fn new5 (new_buffer : * mut yamm_ns_yamm_buffer) -> Self { let mut __bindgen_tmp = :: std :: mem :: MaybeUninit :: uninit () ; yamm_ns_yamm_buffer_yamm_buffer5 (__bindgen_tmp . as_mut_ptr () , new_buffer) ; __bindgen_tmp . assume_init () } } extern "C" { # [doc = " Store custom data in the buffer. If the size of the data array set\n doesn’t match the size of the buffer, a warning will be triggered.\n\n @param payload The string that is going to be saved as payload inside the buffer\n @param size Size in bytes of the payload\n @return 1 if success , 0 otherwise\n"] # [link_name = "\u{1}_ZN7yamm_ns11yamm_buffer12set_contentsEPcy"] pub fn yamm_ns_yamm_buffer_set_contents (this : * mut :: std :: os :: raw :: c_void , payload : * mut :: std :: os :: raw :: c_char , size : yamm_ns_uint_64_t) -> bool ; } extern "C" { # [doc = " A hook function which the user can extend to implement a custom generation\n rule for data. By default it generates pure random data which is then\n stored with set_contents().\n\n Function can be overwritten by user for custom comparison."] # [link_name = "\u{1}_ZN7yamm_ns11yamm_buffer24generate_random_contentsEv"] pub fn yamm_ns_yamm_buffer_generate_random_contents (this : * mut :: std :: os :: raw :: c_void) -> bool ; } extern "C" { # [doc = " This function returns the data stored in the buffer. If no data\n was previously stored with set_contents() it will do a call to\n generate_contents() to get data.\n\n @return Contents stored inside the buffer"] # [link_name = "\u{1}_ZN7yamm_ns11yamm_buffer12get_contentsEv"] pub fn yamm_ns_yamm_buffer_get_contents (this : * mut :: std :: os :: raw :: c_void) -> * mut :: std :: os :: raw :: c_char ; } extern "C" { # [doc = " Function that compares the content from current buffer to the reference\n\n @param reference Content that will be compared\n @param ref_size Size in bytes of the reference param\n\n @return 1 if contents are equal, 0 otherwise"] # [link_name = "\u{1}_ZN7yamm_ns11yamm_buffer16compare_contentsEPcy"] pub fn yamm_ns_yamm_buffer_compare_contents (this : * mut :: std :: os :: raw :: c_void , reference : * mut :: std :: os :: raw :: c_char , ref_size : yamm_ns_uint_64_t) -> bool ; } extern "C" { # [doc = " Destructor\n Frees everything"] # [link_name = "\u{1}_ZN7yamm_ns11yamm_bufferD1Ev"] pub fn yamm_ns_yamm_buffer_yamm_buffer_destructor (this : * mut yamm_ns_yamm_buffer) ; } # [doc = " Top level class"] # [repr (C)] pub struct yamm_ns_yamm { pub _base : yamm_ns_yamm_buffer , pub init_done : bool , pub static_buffers_queue : std_queue < std_deque > , } # [test] fn bindgen_test_layout_yamm_ns_yamm () { const UNINIT : :: std :: mem :: MaybeUninit < yamm_ns_yamm > = :: std :: mem :: MaybeUninit :: uninit () ; let ptr = UNINIT . as_ptr () ; assert_eq ! (:: std :: mem :: size_of :: < yamm_ns_yamm > () , 232usize , concat ! ("Size of: " , stringify ! (yamm_ns_yamm))) ; assert_eq ! (:: std :: mem :: align_of :: < yamm_ns_yamm > () , 8usize , concat ! ("Alignment of " , stringify ! (yamm_ns_yamm))) ; assert_eq ! (unsafe { :: std :: ptr :: addr_of ! ((* ptr) . init_done) as usize - ptr as usize } , 146usize , concat ! ("Offset of field: " , stringify ! (yamm_ns_yamm) , "::" , stringify ! (init_done))) ; assert_eq ! (unsafe { :: std :: ptr :: addr_of ! ((* ptr) . static_buffers_queue) as usize - ptr as usize } , 152usize , concat ! ("Offset of field: " , stringify ! (yamm_ns_yamm) , "::" , stringify ! (static_buffers_queue))) ; } extern "C" { # [doc = " Function that builds the memory and allows usage.\n\n @param size Total size of the memory"] # [link_name = "\u{1}_ZN7yamm_ns4yamm5buildEy"] pub fn yamm_ns_yamm_build (this : * mut yamm_ns_yamm , size : yamm_ns_uint_64_t) ; } extern "C" { # [doc = " Inserts ( if it cans) the buffer n in static mode.\n If the buffer is in static mode it won't be affected by soft resets or deallocations.\n The function should only be called from the top module (main)\n @param n The buffer created by the user that will be inserted"] # [link_name = "\u{1}_ZN7yamm_ns4yamm15allocate_staticEPNS_11yamm_bufferE"] pub fn yamm_ns_yamm_allocate_static (this : * mut yamm_ns_yamm , n : * mut yamm_ns_yamm_buffer) -> bool ; } extern "C" { # [doc = " Getter for the static buffers queue"] # [link_name = "\u{1}_ZN7yamm_ns4yamm18get_static_buffersEv"] pub fn yamm_ns_yamm_get_static_buffers (this : * mut yamm_ns_yamm) -> std_queue < std_deque > ; } extern "C" { # [doc = " Default constructor.\n Everything is initialized to it's default value."] # [link_name = "\u{1}_ZN7yamm_ns4yammC1Ev"] pub fn yamm_ns_yamm_yamm (this : * mut yamm_ns_yamm) ; } impl yamm_ns_yamm { # [inline] pub unsafe fn build (& mut self , size : yamm_ns_uint_64_t) { yamm_ns_yamm_build (self , size) } # [inline] pub unsafe fn allocate_static (& mut self , n : * mut yamm_ns_yamm_buffer) -> bool { yamm_ns_yamm_allocate_static (self , n) } # [inline] pub unsafe fn get_static_buffers (& mut self) -> std_queue < std_deque > { yamm_ns_yamm_get_static_buffers (self) } # [inline] pub unsafe fn new () -> Self { let mut __bindgen_tmp = :: std :: mem :: MaybeUninit :: uninit () ; yamm_ns_yamm_yamm (__bindgen_tmp . as_mut_ptr ()) ; __bindgen_tmp . assume_init () } } extern "C" { # [doc = " Standard destructor."] # [link_name = "\u{1}_ZN7yamm_ns4yammD1Ev"] pub fn yamm_ns_yamm_yamm_destructor (this : * mut yamm_ns_yamm) ; } # [test] fn __bindgen_test_layout_std_basic_string_open0_char_std_char_traits_open1_char_close1_std_allocator_open1_char_close1_close0_instantiation () { assert_eq ! (:: std :: mem :: size_of :: < std_basic_string < :: std :: os :: raw :: c_char > > () , 32usize , concat ! ("Size of template specialization: " , stringify ! (std_basic_string < :: std :: os :: raw :: c_char >))) ; assert_eq ! (:: std :: mem :: align_of :: < std_basic_string < :: std :: os :: raw :: c_char > > () , 8usize , concat ! ("Alignment of template specialization: " , stringify ! (std_basic_string < :: std :: os :: raw :: c_char >))) ; } # [test] fn __bindgen_test_layout_std_char_traits_open0_char_close0_instantiation () { assert_eq ! (:: std :: mem :: size_of :: < std_char_traits > () , 1usize , concat ! ("Size of template specialization: " , stringify ! (std_char_traits))) ; assert_eq ! (:: std :: mem :: align_of :: < std_char_traits > () , 1usize , concat ! ("Alignment of template specialization: " , stringify ! (std_char_traits))) ; } # [test] fn __bindgen_test_layout_std_allocator_open0_char_close0_instantiation () { assert_eq ! (:: std :: mem :: size_of :: < std_allocator > () , 1usize , concat ! ("Size of template specialization: " , stringify ! (std_allocator))) ; assert_eq ! (:: std :: mem :: align_of :: < std_allocator > () , 1usize , concat ! ("Alignment of template specialization: " , stringify ! (std_allocator))) ; } # [repr (C)] # [derive (Debug , Copy , Clone)] pub struct _bindgen_ty_2 { pub _address : u8 , } # [test] fn __bindgen_test_layout_std_queue_open0_ptr_yamm_buffer_std_deque_open1_ptr_yamm_buffer_std_allocator_open2_ptr_yamm_buffer_close2_close1_close0_instantiation () { assert_eq ! (:: std :: mem :: size_of :: < std_queue < std_deque > > () , 80usize , concat ! ("Size of template specialization: " , stringify ! (std_queue < std_deque >))) ; assert_eq ! (:: std :: mem :: align_of :: < std_queue < std_deque > > () , 8usize , concat ! ("Alignment of template specialization: " , stringify ! (std_queue < std_deque >))) ; } # [test] fn __bindgen_test_layout_std_deque_open0_ptr_yamm_buffer_std_allocator_open1_ptr_yamm_buffer_close1_close0_instantiation () { assert_eq ! (:: std :: mem :: size_of :: < std_deque > () , 80usize , concat ! ("Size of template specialization: " , stringify ! (std_deque))) ; assert_eq ! (:: std :: mem :: align_of :: < std_deque > () , 8usize , concat ! ("Alignment of template specialization: " , stringify ! (std_deque))) ; } # [test] fn __bindgen_test_layout_std_allocator_open0_ptr_yamm_buffer_close0_instantiation () { assert_eq ! (:: std :: mem :: size_of :: < std_allocator > () , 1usize , concat ! ("Size of template specialization: " , stringify ! (std_allocator))) ; assert_eq ! (:: std :: mem :: align_of :: < std_allocator > () , 1usize , concat ! ("Alignment of template specialization: " , stringify ! (std_allocator))) ; } # [test] fn __bindgen_test_layout_std_queue_open0_ptr_yamm_buffer_std_deque_open1_ptr_yamm_buffer_std_allocator_open2_ptr_yamm_buffer_close2_close1_close0_instantiation_1 () { assert_eq ! (:: std :: mem :: size_of :: < std_queue < std_deque > > () , 80usize , concat ! ("Size of template specialization: " , stringify ! (std_queue < std_deque >))) ; assert_eq ! (:: std :: mem :: align_of :: < std_queue < std_deque > > () , 8usize , concat ! ("Alignment of template specialization: " , stringify ! (std_queue < std_deque >))) ; } # [test] fn __bindgen_test_layout_std_deque_open0_ptr_yamm_buffer_std_allocator_open1_ptr_yamm_buffer_close1_close0_instantiation_1 () { assert_eq ! (:: std :: mem :: size_of :: < std_deque > () , 80usize , concat ! ("Size of template specialization: " , stringify ! (std_deque))) ; assert_eq ! (:: std :: mem :: align_of :: < std_deque > () , 8usize , concat ! ("Alignment of template specialization: " , stringify ! (std_deque))) ; } # [test] fn __bindgen_test_layout_std_allocator_open0_ptr_yamm_buffer_close0_instantiation_1 () { assert_eq ! (:: std :: mem :: size_of :: < std_allocator > () , 1usize , concat ! ("Size of template specialization: " , stringify ! (std_allocator))) ; assert_eq ! (:: std :: mem :: align_of :: < std_allocator > () , 1usize , concat ! ("Alignment of template specialization: " , stringify ! (std_allocator))) ; } [INFO] [stdout] | +++++++++++++++++++++++ + [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] For more information about this error, try `rustc --explain E0740`. [INFO] [stdout] [INFO] [stderr] error: could not compile `yamm-sys` (lib) due to 1 previous error [INFO] running `Command { std: "docker" "inspect" "334da9a214660306cb6b4625890dae6685be015c86b3c54f18975931ead55dc7", kill_on_drop: false }` [INFO] running `Command { std: "docker" "rm" "-f" "334da9a214660306cb6b4625890dae6685be015c86b3c54f18975931ead55dc7", kill_on_drop: false }` [INFO] [stdout] 334da9a214660306cb6b4625890dae6685be015c86b3c54f18975931ead55dc7