[INFO] fetching crate apache-nimble-sys 0.0.1...
[INFO] checking apache-nimble-sys-0.0.1 against master#b0696a5160711c068cb1f01b7437db7990d15750 for pr-121848
[INFO] extracting crate apache-nimble-sys 0.0.1 into /workspace/builds/worker-5-tc1/source
[INFO] validating manifest of crates.io crate apache-nimble-sys 0.0.1 on toolchain b0696a5160711c068cb1f01b7437db7990d15750
[INFO] running `Command { std: CARGO_HOME="/workspace/cargo-home" RUSTUP_HOME="/workspace/rustup-home" "/workspace/cargo-home/bin/cargo" "+b0696a5160711c068cb1f01b7437db7990d15750" "metadata" "--manifest-path" "Cargo.toml" "--no-deps", kill_on_drop: false }`
[INFO] started tweaking crates.io crate apache-nimble-sys 0.0.1
[INFO] finished tweaking crates.io crate apache-nimble-sys 0.0.1
[INFO] tweaked toml for crates.io crate apache-nimble-sys 0.0.1 written to /workspace/builds/worker-5-tc1/source/Cargo.toml
[INFO] running `Command { std: CARGO_HOME="/workspace/cargo-home" RUSTUP_HOME="/workspace/rustup-home" "/workspace/cargo-home/bin/cargo" "+b0696a5160711c068cb1f01b7437db7990d15750" "generate-lockfile" "--manifest-path" "Cargo.toml", kill_on_drop: false }`
[INFO] [stderr]     Updating crates.io index
[INFO] running `Command { std: CARGO_HOME="/workspace/cargo-home" RUSTUP_HOME="/workspace/rustup-home" "/workspace/cargo-home/bin/cargo" "+b0696a5160711c068cb1f01b7437db7990d15750" "fetch" "--manifest-path" "Cargo.toml", kill_on_drop: false }`
[INFO] [stderr] warning: the cargo feature `resolver` has been stabilized in the 1.51 release and is no longer necessary to be listed in the manifest
[INFO] [stderr]   See https://doc.rust-lang.org/nightly/cargo/reference/resolver.html#resolver-versions for more information about using this feature.
[INFO] [stderr]  Downloading crates ...
[INFO] [stderr]   Downloaded lazycell v1.3.0
[INFO] [stderr]   Downloaded which v3.1.1
[INFO] [stderr]   Downloaded libloading v0.5.2
[INFO] [stderr]   Downloaded cexpr v0.4.0
[INFO] [stderr]   Downloaded cty v0.2.2
[INFO] [stderr]   Downloaded peeking_take_while v0.1.2
[INFO] [stderr]   Downloaded shlex v0.1.1
[INFO] [stderr]   Downloaded cstr_core v0.2.6
[INFO] [stderr]   Downloaded glob v0.3.1
[INFO] [stderr]   Downloaded clang-sys v0.29.3
[INFO] [stderr]   Downloaded bindgen v0.53.3
[INFO] [stderr]   Downloaded nom v5.1.3
[INFO] running `Command { std: "docker" "create" "-v" "/var/lib/crater-agent-workspace/builds/worker-5-tc1/target:/opt/rustwide/target:rw,Z" "-v" "/var/lib/crater-agent-workspace/builds/worker-5-tc1/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:2788e3201cd34a07e3172128adcd8b3090168a8e3bcc40d7c032b9dda1df7d1c" "/opt/rustwide/cargo-home/bin/cargo" "+b0696a5160711c068cb1f01b7437db7990d15750" "metadata" "--no-deps" "--format-version=1", kill_on_drop: false }`
[INFO] [stdout] c0ab2d70a97e0a5633dcc2ce82bfe328ac1bd6f9d54bf10055a1da5cc79f7004
[INFO] running `Command { std: "docker" "start" "-a" "c0ab2d70a97e0a5633dcc2ce82bfe328ac1bd6f9d54bf10055a1da5cc79f7004", kill_on_drop: false }`
[INFO] running `Command { std: "docker" "inspect" "c0ab2d70a97e0a5633dcc2ce82bfe328ac1bd6f9d54bf10055a1da5cc79f7004", kill_on_drop: false }`
[INFO] running `Command { std: "docker" "rm" "-f" "c0ab2d70a97e0a5633dcc2ce82bfe328ac1bd6f9d54bf10055a1da5cc79f7004", kill_on_drop: false }`
[INFO] [stdout] c0ab2d70a97e0a5633dcc2ce82bfe328ac1bd6f9d54bf10055a1da5cc79f7004
[INFO] running `Command { std: "docker" "create" "-v" "/var/lib/crater-agent-workspace/builds/worker-5-tc1/target:/opt/rustwide/target:rw,Z" "-v" "/var/lib/crater-agent-workspace/builds/worker-5-tc1/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:2788e3201cd34a07e3172128adcd8b3090168a8e3bcc40d7c032b9dda1df7d1c" "/opt/rustwide/cargo-home/bin/cargo" "+b0696a5160711c068cb1f01b7437db7990d15750" "check" "--frozen" "--all" "--all-targets" "--message-format=json", kill_on_drop: false }`
[INFO] [stdout] 3fa6fcd04c060e906d8f9ddb7b164f9038eb7c418570c80b3917aafc590fb911
[INFO] running `Command { std: "docker" "start" "-a" "3fa6fcd04c060e906d8f9ddb7b164f9038eb7c418570c80b3917aafc590fb911", kill_on_drop: false }`
[INFO] [stderr] warning: the cargo feature `resolver` has been stabilized in the 1.51 release and is no longer necessary to be listed in the manifest
[INFO] [stderr]   See https://doc.rust-lang.org/nightly/cargo/reference/resolver.html#resolver-versions for more information about using this feature.
[INFO] [stderr]    Compiling libc v0.2.153
[INFO] [stderr]    Compiling memchr v2.7.1
[INFO] [stderr]    Compiling glob v0.3.1
[INFO] [stderr]    Compiling cc v1.0.90
[INFO] [stderr]    Compiling proc-macro2 v1.0.78
[INFO] [stderr]    Compiling unicode-width v0.1.11
[INFO] [stderr]    Compiling quick-error v1.2.3
[INFO] [stderr]    Compiling nom v5.1.3
[INFO] [stderr]    Compiling bitflags v1.3.2
[INFO] [stderr]    Compiling ansi_term v0.12.1
[INFO] [stderr]    Compiling strsim v0.8.0
[INFO] [stderr]    Compiling termcolor v1.4.1
[INFO] [stderr]    Compiling bindgen v0.53.3
[INFO] [stderr]    Compiling log v0.4.21
[INFO] [stderr]    Compiling vec_map v0.8.2
[INFO] [stderr]    Compiling lazy_static v1.4.0
[INFO] [stderr]    Compiling humantime v1.3.0
[INFO] [stderr]    Compiling textwrap v0.11.0
[INFO] [stderr]    Compiling lazycell v1.3.0
[INFO] [stderr]    Compiling peeking_take_while v0.1.2
[INFO] [stderr]    Compiling rustc-hash v1.1.0
[INFO] [stderr]    Compiling shlex v0.1.1
[INFO] [stderr]    Compiling cfg-if v0.1.10
[INFO] [stderr]     Checking cty v0.2.2
[INFO] [stderr]    Compiling clang-sys v0.29.3
[INFO] [stderr]    Compiling aho-corasick v1.1.2
[INFO] [stderr]     Checking cstr_core v0.2.6
[INFO] [stderr]    Compiling atty v0.2.14
[INFO] [stderr]    Compiling which v3.1.1
[INFO] [stderr]    Compiling quote v1.0.35
[INFO] [stderr]    Compiling clap v2.34.0
[INFO] [stderr]    Compiling libloading v0.5.2
[INFO] [stderr]    Compiling regex-automata v0.4.6
[INFO] [stderr]    Compiling cexpr v0.4.0
[INFO] [stderr]    Compiling regex v1.10.3
[INFO] [stderr]    Compiling env_logger v0.7.1
[INFO] [stderr]    Compiling apache-nimble-sys v0.0.1 (/opt/rustwide/workdir)
[INFO] [stderr] warning: apache-nimble-sys@0.0.1: Compiler version doesn't include clang or GCC: "cc" "--version"
[INFO] [stdout] warning: unused variable: `ptr`
[INFO] [stdout]  --> src/lib.rs:8:17
[INFO] [stdout]   |
[INFO] [stdout] 8 |     pub fn free(ptr: *mut cty::c_void) {}
[INFO] [stdout]   |                 ^^^ help: if this is intentional, prefix it with an underscore: `_ptr`
[INFO] [stdout]   |
[INFO] [stdout]   = note: `#[warn(unused_variables)]` on by default
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: unused variable: `amt`
[INFO] [stdout]   --> src/lib.rs:11:19
[INFO] [stdout]    |
[INFO] [stdout] 11 |     pub fn malloc(amt: cty::size_t) -> *mut cty::c_void {
[INFO] [stdout]    |                   ^^^ help: if this is intentional, prefix it with an underscore: `_amt`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: unused variable: `file`
[INFO] [stdout]   --> src/lib.rs:16:26
[INFO] [stdout]    |
[INFO] [stdout] 16 |     pub fn __assert_func(file: *const char, line: usize, func: *const char, expr: *const char) {
[INFO] [stdout]    |                          ^^^^ help: if this is intentional, prefix it with an underscore: `_file`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: unused variable: `line`
[INFO] [stdout]   --> src/lib.rs:16:45
[INFO] [stdout]    |
[INFO] [stdout] 16 |     pub fn __assert_func(file: *const char, line: usize, func: *const char, expr: *const char) {
[INFO] [stdout]    |                                             ^^^^ help: if this is intentional, prefix it with an underscore: `_line`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: unused variable: `func`
[INFO] [stdout]   --> src/lib.rs:16:58
[INFO] [stdout]    |
[INFO] [stdout] 16 |     pub fn __assert_func(file: *const char, line: usize, func: *const char, expr: *const char) {
[INFO] [stdout]    |                                                          ^^^^ help: if this is intentional, prefix it with an underscore: `_func`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: unused variable: `expr`
[INFO] [stdout]   --> src/lib.rs:16:77
[INFO] [stdout]    |
[INFO] [stdout] 16 |     pub fn __assert_func(file: *const char, line: usize, func: *const char, expr: *const char) {
[INFO] [stdout]    |                                                                             ^^^^ help: if this is intentional, prefix it with an underscore: `_expr`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0507]: cannot move out of `self.data` which is behind a shared reference
[INFO] [stdout]  --> /opt/rustwide/target/debug/build/apache-nimble-sys-31e8b6fd6077532c/out/bindings.rs:3:152615
[INFO] [stdout]   |
[INFO] [stdout] 3 | ...[derive (Debug)] pub struct ble_hci_cmd { pub opcode : u16 , pub length : u8 , pub data : __IncompleteArrayField < u8 > , } # [test] f...
[INFO] [stdout]   |             ----- in this derive macro expansion                                  ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ move occurs because `self.data` has type `__IncompleteArrayField<u8>`, which does not implement the `Copy` trait
[INFO] [stdout]   |
[INFO] [stdout]   = note: `#[derive(Debug)]` triggers a move because taking references to the fields of a packed struct is undefined behaviour
[INFO] [stdout]   = note: this error originates in the derive macro `Debug` (in Nightly builds, run with -Z macro-backtrace for more info)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0507]: cannot move out of `self.data` which is behind a shared reference
[INFO] [stdout]  --> /opt/rustwide/target/debug/build/apache-nimble-sys-31e8b6fd6077532c/out/bindings.rs:3:153698
[INFO] [stdout]   |
[INFO] [stdout] 3 | ...# [derive (Debug)] pub struct ble_hci_ev { pub opcode : u8 , pub length : u8 , pub data : __IncompleteArrayField < u8 > , } # [test] f...
[INFO] [stdout]   |               ----- in this derive macro expansion                                ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ move occurs because `self.data` has type `__IncompleteArrayField<u8>`, which does not implement the `Copy` trait
[INFO] [stdout]   |
[INFO] [stdout]   = note: `#[derive(Debug)]` triggers a move because taking references to the fields of a packed struct is undefined behaviour
[INFO] [stdout]   = note: this error originates in the derive macro `Debug` (in Nightly builds, run with -Z macro-backtrace for more info)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0507]: cannot move out of `self.h` which is behind a shared reference
[INFO] [stdout]  --> /opt/rustwide/target/debug/build/apache-nimble-sys-31e8b6fd6077532c/out/bindings.rs:3:162736
[INFO] [stdout]   |
[INFO] [stdout] 3 | ...e (Debug)] pub struct ble_hci_cb_host_num_comp_pkts_cp { pub handles : u8 , pub h : __IncompleteArrayField < ble_hci_cb_host_num_comp_pkts_entry > , ...
[INFO] [stdout]   |       ----- in this derive macro expansion                                     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ move occurs because `self.h` has type `__IncompleteArrayField<ble_hci_cb_host_num_comp_pkts_entry>`, which does not implement the `Copy` trait
[INFO] [stdout]   |
[INFO] [stdout]   = note: `#[derive(Debug)]` triggers a move because taking references to the fields of a packed struct is undefined behaviour
[INFO] [stdout]   = note: this error originates in the derive macro `Debug` (in Nightly builds, run with -Z macro-backtrace for more info)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0507]: cannot move out of `self.adv_data` which is behind a shared reference
[INFO] [stdout]  --> /opt/rustwide/target/debug/build/apache-nimble-sys-31e8b6fd6077532c/out/bindings.rs:3:248112
[INFO] [stdout]   |
[INFO] [stdout] 3 | ...e (Debug)] pub struct ble_hci_le_set_ext_adv_data_cp { pub adv_handle : u8 , pub operation : u8 , pub fragment_pref : u8 , pub adv_data_len : u8 , pub adv_data : __IncompleteArrayField < u8 > , ...
[INFO] [stdout]   |       ----- in this derive macro expansion                                                                                                            ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ move occurs because `self.adv_data` has type `__IncompleteArrayField<u8>`, which does not implement the `Copy` trait
[INFO] [stdout]   |
[INFO] [stdout]   = note: `#[derive(Debug)]` triggers a move because taking references to the fields of a packed struct is undefined behaviour
[INFO] [stdout]   = note: this error originates in the derive macro `Debug` (in Nightly builds, run with -Z macro-backtrace for more info)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0507]: cannot move out of `self.scan_rsp` which is behind a shared reference
[INFO] [stdout]  --> /opt/rustwide/target/debug/build/apache-nimble-sys-31e8b6fd6077532c/out/bindings.rs:3:250035
[INFO] [stdout]   |
[INFO] [stdout] 3 | ...e (Debug)] pub struct ble_hci_le_set_ext_scan_rsp_data_cp { pub adv_handle : u8 , pub operation : u8 , pub fragment_pref : u8 , pub scan_rsp_len : u8 , pub scan_rsp : __IncompleteArrayField < u8 > , ...
[INFO] [stdout]   |       ----- in this derive macro expansion                                                                                                                 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ move occurs because `self.scan_rsp` has type `__IncompleteArrayField<u8>`, which does not implement the `Copy` trait
[INFO] [stdout]   |
[INFO] [stdout]   = note: `#[derive(Debug)]` triggers a move because taking references to the fields of a packed struct is undefined behaviour
[INFO] [stdout]   = note: this error originates in the derive macro `Debug` (in Nightly builds, run with -Z macro-backtrace for more info)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0507]: cannot move out of `self.sets` which is behind a shared reference
[INFO] [stdout]  --> /opt/rustwide/target/debug/build/apache-nimble-sys-31e8b6fd6077532c/out/bindings.rs:3:253037
[INFO] [stdout]   |
[INFO] [stdout] 3 | ...e (Debug)] pub struct ble_hci_le_set_ext_adv_enable_cp { pub enable : u8 , pub num_sets : u8 , pub sets : __IncompleteArrayField < adv_set > , ...
[INFO] [stdout]   |       ----- in this derive macro expansion                                                        ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ move occurs because `self.sets` has type `__IncompleteArrayField<adv_set>`, which does not implement the `Copy` trait
[INFO] [stdout]   |
[INFO] [stdout]   = note: `#[derive(Debug)]` triggers a move because taking references to the fields of a packed struct is undefined behaviour
[INFO] [stdout]   = note: this error originates in the derive macro `Debug` (in Nightly builds, run with -Z macro-backtrace for more info)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0507]: cannot move out of `self.adv_data` which is behind a shared reference
[INFO] [stdout]  --> /opt/rustwide/target/debug/build/apache-nimble-sys-31e8b6fd6077532c/out/bindings.rs:3:258500
[INFO] [stdout]   |
[INFO] [stdout] 3 | ...e (Debug)] pub struct ble_hci_le_set_periodic_adv_data_cp { pub adv_handle : u8 , pub operation : u8 , pub adv_data_len : u8 , pub adv_data : __IncompleteArrayField < u8 > , ...
[INFO] [stdout]   |       ----- in this derive macro expansion                                                                                        ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ move occurs because `self.adv_data` has type `__IncompleteArrayField<u8>`, which does not implement the `Copy` trait
[INFO] [stdout]   |
[INFO] [stdout]   = note: `#[derive(Debug)]` triggers a move because taking references to the fields of a packed struct is undefined behaviour
[INFO] [stdout]   = note: this error originates in the derive macro `Debug` (in Nightly builds, run with -Z macro-backtrace for more info)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0507]: cannot move out of `self.scans` which is behind a shared reference
[INFO] [stdout]  --> /opt/rustwide/target/debug/build/apache-nimble-sys-31e8b6fd6077532c/out/bindings.rs:3:262389
[INFO] [stdout]   |
[INFO] [stdout] 3 | ...e (Debug)] pub struct ble_hci_le_set_ext_scan_params_cp { pub own_addr_type : u8 , pub filter_policy : u8 , pub phys : u8 , pub scans : __IncompleteArrayField < scan_params > , ...
[INFO] [stdout]   |       ----- in this derive macro expansion                                                                                     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ move occurs because `self.scans` has type `__IncompleteArrayField<scan_params>`, which does not implement the `Copy` trait
[INFO] [stdout]   |
[INFO] [stdout]   = note: `#[derive(Debug)]` triggers a move because taking references to the fields of a packed struct is undefined behaviour
[INFO] [stdout]   = note: this error originates in the derive macro `Debug` (in Nightly builds, run with -Z macro-backtrace for more info)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0507]: cannot move out of `self.conn_params` which is behind a shared reference
[INFO] [stdout]  --> /opt/rustwide/target/debug/build/apache-nimble-sys-31e8b6fd6077532c/out/bindings.rs:3:268114
[INFO] [stdout]   |
[INFO] [stdout] 3 | ...e (Debug)] pub struct ble_hci_le_ext_create_conn_cp { pub filter_policy : u8 , pub own_addr_type : u8 , pub peer_addr_type : u8 , pub peer_addr : [u8 ; 6usize] , pub init_phy_mask : u8 , pub conn_params : __IncompleteArrayField < conn_params > , ...
[INFO] [stdout]   |       ----- in this derive macro expansion                                                                                                                                                    ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ move occurs because `self.conn_params` has type `__IncompleteArrayField<conn_params>`, which does not implement the `Copy` trait
[INFO] [stdout]   |
[INFO] [stdout]   = note: `#[derive(Debug)]` triggers a move because taking references to the fields of a packed struct is undefined behaviour
[INFO] [stdout]   = note: this error originates in the derive macro `Debug` (in Nightly builds, run with -Z macro-backtrace for more info)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0507]: cannot move out of `self.return_params` which is behind a shared reference
[INFO] [stdout]  --> /opt/rustwide/target/debug/build/apache-nimble-sys-31e8b6fd6077532c/out/bindings.rs:3:299510
[INFO] [stdout]   |
[INFO] [stdout] 3 | ...e (Debug)] pub struct ble_hci_ev_command_complete { pub num_packets : u8 , pub opcode : u16 , pub status : u8 , pub return_params : __IncompleteArrayField < u8 > , ...
[INFO] [stdout]   |       ----- in this derive macro expansion                                                                         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ move occurs because `self.return_params` has type `__IncompleteArrayField<u8>`, which does not implement the `Copy` trait
[INFO] [stdout]   |
[INFO] [stdout]   = note: `#[derive(Debug)]` triggers a move because taking references to the fields of a packed struct is undefined behaviour
[INFO] [stdout]   = note: this error originates in the derive macro `Debug` (in Nightly builds, run with -Z macro-backtrace for more info)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0507]: cannot move out of `self.completed` which is behind a shared reference
[INFO] [stdout]  --> /opt/rustwide/target/debug/build/apache-nimble-sys-31e8b6fd6077532c/out/bindings.rs:3:304882
[INFO] [stdout]   |
[INFO] [stdout] 3 | ...erive (Debug)] pub struct ble_hci_ev_num_comp_pkts { pub count : u8 , pub completed : __IncompleteArrayField < comp_pkt > , } # [test]...
[INFO] [stdout]   |           ----- in this derive macro expansion                           ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ move occurs because `self.completed` has type `__IncompleteArrayField<comp_pkt>`, which does not implement the `Copy` trait
[INFO] [stdout]   |
[INFO] [stdout]   = note: `#[derive(Debug)]` triggers a move because taking references to the fields of a packed struct is undefined behaviour
[INFO] [stdout]   = note: this error originates in the derive macro `Debug` (in Nightly builds, run with -Z macro-backtrace for more info)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0507]: cannot move out of `self.data` which is behind a shared reference
[INFO] [stdout]  --> /opt/rustwide/target/debug/build/apache-nimble-sys-31e8b6fd6077532c/out/bindings.rs:3:307662
[INFO] [stdout]   |
[INFO] [stdout] 3 | ...] # [derive (Debug)] pub struct ble_hci_ev_le_meta { pub subevent : u8 , pub data : __IncompleteArrayField < u8 > , } # [test] fn bind...
[INFO] [stdout]   |                 ----- in this derive macro expansion                        ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ move occurs because `self.data` has type `__IncompleteArrayField<u8>`, which does not implement the `Copy` trait
[INFO] [stdout]   |
[INFO] [stdout]   = note: `#[derive(Debug)]` triggers a move because taking references to the fields of a packed struct is undefined behaviour
[INFO] [stdout]   = note: this error originates in the derive macro `Debug` (in Nightly builds, run with -Z macro-backtrace for more info)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0507]: cannot move out of `self.data` which is behind a shared reference
[INFO] [stdout]  --> /opt/rustwide/target/debug/build/apache-nimble-sys-31e8b6fd6077532c/out/bindings.rs:3:309332
[INFO] [stdout]   |
[INFO] [stdout] 3 | ...] # [derive (Debug)] pub struct ble_hci_ev_vendor_debug { pub id : u8 , pub data : __IncompleteArrayField < u8 > , } # [test] fn bindg...
[INFO] [stdout]   |                 ----- in this derive macro expansion                       ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ move occurs because `self.data` has type `__IncompleteArrayField<u8>`, which does not implement the `Copy` trait
[INFO] [stdout]   |
[INFO] [stdout]   = note: `#[derive(Debug)]` triggers a move because taking references to the fields of a packed struct is undefined behaviour
[INFO] [stdout]   = note: this error originates in the derive macro `Debug` (in Nightly builds, run with -Z macro-backtrace for more info)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0507]: cannot move out of `self.data` which is behind a shared reference
[INFO] [stdout]  --> /opt/rustwide/target/debug/build/apache-nimble-sys-31e8b6fd6077532c/out/bindings.rs:3:313737
[INFO] [stdout]   |
[INFO] [stdout] 3 | ...e (Debug)] pub struct adv_report { pub type_ : u8 , pub addr_type : u8 , pub addr : [u8 ; 6usize] , pub data_len : u8 , pub data : __IncompleteArrayField < u8 > , ...
[INFO] [stdout]   |       ----- in this derive macro expansion                                                                                 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ move occurs because `self.data` has type `__IncompleteArrayField<u8>`, which does not implement the `Copy` trait
[INFO] [stdout]   |
[INFO] [stdout]   = note: `#[derive(Debug)]` triggers a move because taking references to the fields of a packed struct is undefined behaviour
[INFO] [stdout]   = note: this error originates in the derive macro `Debug` (in Nightly builds, run with -Z macro-backtrace for more info)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0507]: cannot move out of `self.reports` which is behind a shared reference
[INFO] [stdout]  --> /opt/rustwide/target/debug/build/apache-nimble-sys-31e8b6fd6077532c/out/bindings.rs:3:315257
[INFO] [stdout]   |
[INFO] [stdout] 3 | ...e (Debug)] pub struct ble_hci_ev_le_subev_adv_rpt { pub subev_code : u8 , pub num_reports : u8 , pub reports : __IncompleteArrayField < adv_report > , ...
[INFO] [stdout]   |       ----- in this derive macro expansion                                                          ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ move occurs because `self.reports` has type `__IncompleteArrayField<adv_report>`, which does not implement the `Copy` trait
[INFO] [stdout]   |
[INFO] [stdout]   = note: `#[derive(Debug)]` triggers a move because taking references to the fields of a packed struct is undefined behaviour
[INFO] [stdout]   = note: this error originates in the derive macro `Debug` (in Nightly builds, run with -Z macro-backtrace for more info)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0507]: cannot move out of `self.reports` which is behind a shared reference
[INFO] [stdout]  --> /opt/rustwide/target/debug/build/apache-nimble-sys-31e8b6fd6077532c/out/bindings.rs:3:335593
[INFO] [stdout]   |
[INFO] [stdout] 3 | ...e (Debug)] pub struct ble_hci_ev_le_subev_direct_adv_rpt { pub subev_code : u8 , pub num_reports : u8 , pub reports : __IncompleteArrayField < dir_adv_report > , ...
[INFO] [stdout]   |       ----- in this derive macro expansion                                                                 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ move occurs because `self.reports` has type `__IncompleteArrayField<dir_adv_report>`, which does not implement the `Copy` trait
[INFO] [stdout]   |
[INFO] [stdout]   = note: `#[derive(Debug)]` triggers a move because taking references to the fields of a packed struct is undefined behaviour
[INFO] [stdout]   = note: this error originates in the derive macro `Debug` (in Nightly builds, run with -Z macro-backtrace for more info)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0507]: cannot move out of `self.data` which is behind a shared reference
[INFO] [stdout]  --> /opt/rustwide/target/debug/build/apache-nimble-sys-31e8b6fd6077532c/out/bindings.rs:3:339208
[INFO] [stdout]   |
[INFO] [stdout] 3 | ...e (Debug)] pub struct ext_adv_report { pub evt_type : u16 , pub addr_type : u8 , pub addr : [u8 ; 6usize] , pub pri_phy : u8 , pub sec_phy : u8 , pub sid : u8 , pub tx_power : i8 , pub rssi : i8 , pub periodic_itvl : u16 , pub dir_addr_type : u8 , pub dir_addr : [u8 ; 6usize] , pub data_len : u8 , pub data : __IncompleteArrayField < u8 > , ...
[INFO] [stdout]   |       ----- in this derive macro expansion                                                                                                                                                                                                                                                                    ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ move occurs because `self.data` has type `__IncompleteArrayField<u8>`, which does not implement the `Copy` trait
[INFO] [stdout]   |
[INFO] [stdout]   = note: `#[derive(Debug)]` triggers a move because taking references to the fields of a packed struct is undefined behaviour
[INFO] [stdout]   = note: this error originates in the derive macro `Debug` (in Nightly builds, run with -Z macro-backtrace for more info)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0507]: cannot move out of `self.reports` which is behind a shared reference
[INFO] [stdout]  --> /opt/rustwide/target/debug/build/apache-nimble-sys-31e8b6fd6077532c/out/bindings.rs:3:342574
[INFO] [stdout]   |
[INFO] [stdout] 3 | ...e (Debug)] pub struct ble_hci_ev_le_subev_ext_adv_rpt { pub subev_code : u8 , pub num_reports : u8 , pub reports : __IncompleteArrayField < ext_adv_report > , ...
[INFO] [stdout]   |       ----- in this derive macro expansion                                                              ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ move occurs because `self.reports` has type `__IncompleteArrayField<ext_adv_report>`, which does not implement the `Copy` trait
[INFO] [stdout]   |
[INFO] [stdout]   = note: `#[derive(Debug)]` triggers a move because taking references to the fields of a packed struct is undefined behaviour
[INFO] [stdout]   = note: this error originates in the derive macro `Debug` (in Nightly builds, run with -Z macro-backtrace for more info)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0507]: cannot move out of `self.data` which is behind a shared reference
[INFO] [stdout]  --> /opt/rustwide/target/debug/build/apache-nimble-sys-31e8b6fd6077532c/out/bindings.rs:3:347327
[INFO] [stdout]   |
[INFO] [stdout] 3 | ...e (Debug)] pub struct ble_hci_ev_le_subev_periodic_adv_rpt { pub subev_code : u8 , pub sync_handle : u16 , pub tx_power : i8 , pub rssi : i8 , pub cte_type : u8 , pub data_status : u8 , pub data_len : u8 , pub data : __IncompleteArrayField < u8 > , ...
[INFO] [stdout]   |       ----- in this derive macro expansion                                                                                                                                                                       ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ move occurs because `self.data` has type `__IncompleteArrayField<u8>`, which does not implement the `Copy` trait
[INFO] [stdout]   |
[INFO] [stdout]   = note: `#[derive(Debug)]` triggers a move because taking references to the fields of a packed struct is undefined behaviour
[INFO] [stdout]   = note: this error originates in the derive macro `Debug` (in Nightly builds, run with -Z macro-backtrace for more info)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0507]: cannot move out of `self.bis` which is behind a shared reference
[INFO] [stdout]  --> /opt/rustwide/target/debug/build/apache-nimble-sys-31e8b6fd6077532c/out/bindings.rs:3:368725
[INFO] [stdout]   |
[INFO] [stdout] 3 | ...e (Debug)] pub struct ble_hci_ev_le_subev_big_complete { pub subev_code : u8 , pub status : u8 , pub big_handle : u8 , pub big_sync_delay : [u8 ; 3usize] , pub transport_latency : [u8 ; 3usize] , pub phy : u8 , pub nse : u8 , pub bn : u8 , pub pto : u8 , pub irc : u8 , pub max_pdu : u16 , pub iso_interval : u16 , pub bis_cnt : u8 , pub bis : __IncompleteArrayField < u16 > , ...
[INFO] [stdout]   |       ----- in this derive macro expansion                                                                                                                                                                                                                                                                                                       ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ move occurs because `self.bis` has type `__IncompleteArrayField<u16>`, which does not implement the `Copy` trait
[INFO] [stdout]   |
[INFO] [stdout]   = note: `#[derive(Debug)]` triggers a move because taking references to the fields of a packed struct is undefined behaviour
[INFO] [stdout]   = note: this error originates in the derive macro `Debug` (in Nightly builds, run with -Z macro-backtrace for more info)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0507]: cannot move out of `self.bis_handles` which is behind a shared reference
[INFO] [stdout]  --> /opt/rustwide/target/debug/build/apache-nimble-sys-31e8b6fd6077532c/out/bindings.rs:3:374560
[INFO] [stdout]   |
[INFO] [stdout] 3 | ...e (Debug)] pub struct ble_hci_ev_le_subev_big_sync_established { pub subev_code : u8 , pub status : u8 , pub big_handle : u8 , pub transport_latency : [u8 ; 3usize] , pub nse : u8 , pub bn : u8 , pub pto : u8 , pub irc : u8 , pub max_pdu : u16 , pub iso_interval : u16 , pub bis_cnt : u8 , pub bis_handles : __IncompleteArrayField < u16 > , ...
[INFO] [stdout]   |       ----- in this derive macro expansion                                                                                                                                                                                                                                                           ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ move occurs because `self.bis_handles` has type `__IncompleteArrayField<u16>`, which does not implement the `Copy` trait
[INFO] [stdout]   |
[INFO] [stdout]   = note: `#[derive(Debug)]` triggers a move because taking references to the fields of a packed struct is undefined behaviour
[INFO] [stdout]   = note: this error originates in the derive macro `Debug` (in Nightly builds, run with -Z macro-backtrace for more info)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: aborting due to 21 previous errors; 6 warnings emitted
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] For more information about this error, try `rustc --explain E0507`.
[INFO] [stdout] 
[INFO] [stderr] The following warnings were emitted during compilation:
[INFO] [stderr] 
[INFO] [stderr] warning: apache-nimble-sys@0.0.1: Compiler version doesn't include clang or GCC: "cc" "--version"
[INFO] [stderr] 
[INFO] [stderr] error: could not compile `apache-nimble-sys` (lib) due to 22 previous errors; 6 warnings emitted
[INFO] [stderr] warning: build failed, waiting for other jobs to finish...
[INFO] [stdout] warning: unused variable: `ptr`
[INFO] [stdout]  --> src/lib.rs:8:17
[INFO] [stdout]   |
[INFO] [stdout] 8 |     pub fn free(ptr: *mut cty::c_void) {}
[INFO] [stdout]   |                 ^^^ help: if this is intentional, prefix it with an underscore: `_ptr`
[INFO] [stdout]   |
[INFO] [stdout]   = note: `#[warn(unused_variables)]` on by default
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: unused variable: `amt`
[INFO] [stdout]   --> src/lib.rs:11:19
[INFO] [stdout]    |
[INFO] [stdout] 11 |     pub fn malloc(amt: cty::size_t) -> *mut cty::c_void {
[INFO] [stdout]    |                   ^^^ help: if this is intentional, prefix it with an underscore: `_amt`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: unused variable: `file`
[INFO] [stdout]   --> src/lib.rs:16:26
[INFO] [stdout]    |
[INFO] [stdout] 16 |     pub fn __assert_func(file: *const char, line: usize, func: *const char, expr: *const char) {
[INFO] [stdout]    |                          ^^^^ help: if this is intentional, prefix it with an underscore: `_file`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: unused variable: `line`
[INFO] [stdout]   --> src/lib.rs:16:45
[INFO] [stdout]    |
[INFO] [stdout] 16 |     pub fn __assert_func(file: *const char, line: usize, func: *const char, expr: *const char) {
[INFO] [stdout]    |                                             ^^^^ help: if this is intentional, prefix it with an underscore: `_line`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: unused variable: `func`
[INFO] [stdout]   --> src/lib.rs:16:58
[INFO] [stdout]    |
[INFO] [stdout] 16 |     pub fn __assert_func(file: *const char, line: usize, func: *const char, expr: *const char) {
[INFO] [stdout]    |                                                          ^^^^ help: if this is intentional, prefix it with an underscore: `_func`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: unused variable: `expr`
[INFO] [stdout]   --> src/lib.rs:16:77
[INFO] [stdout]    |
[INFO] [stdout] 16 |     pub fn __assert_func(file: *const char, line: usize, func: *const char, expr: *const char) {
[INFO] [stdout]    |                                                                             ^^^^ help: if this is intentional, prefix it with an underscore: `_expr`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0507]: cannot move out of `self.data` which is behind a shared reference
[INFO] [stdout]  --> /opt/rustwide/target/debug/build/apache-nimble-sys-31e8b6fd6077532c/out/bindings.rs:3:152615
[INFO] [stdout]   |
[INFO] [stdout] 3 | ...[derive (Debug)] pub struct ble_hci_cmd { pub opcode : u16 , pub length : u8 , pub data : __IncompleteArrayField < u8 > , } # [test] f...
[INFO] [stdout]   |             ----- in this derive macro expansion                                  ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ move occurs because `self.data` has type `__IncompleteArrayField<u8>`, which does not implement the `Copy` trait
[INFO] [stdout]   |
[INFO] [stdout]   = note: `#[derive(Debug)]` triggers a move because taking references to the fields of a packed struct is undefined behaviour
[INFO] [stdout]   = note: this error originates in the derive macro `Debug` (in Nightly builds, run with -Z macro-backtrace for more info)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]  --> /opt/rustwide/target/debug/build/apache-nimble-sys-31e8b6fd6077532c/out/bindings.rs:3:152988
[INFO] [stdout]   |
[INFO] [stdout] 3 | ..._hci_cmd))) ; assert_eq ! (unsafe { & (* (:: core :: ptr :: null :: < ble_hci_cmd > ())) . opcode as * const _ as usize } , 0usize , c...
[INFO] [stdout]   |                                        ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]   |
[INFO] [stdout]   = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]   = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]   = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0507]: cannot move out of `self.data` which is behind a shared reference
[INFO] [stdout]  --> /opt/rustwide/target/debug/build/apache-nimble-sys-31e8b6fd6077532c/out/bindings.rs:3:153698
[INFO] [stdout]   |
[INFO] [stdout] 3 | ...# [derive (Debug)] pub struct ble_hci_ev { pub opcode : u8 , pub length : u8 , pub data : __IncompleteArrayField < u8 > , } # [test] f...
[INFO] [stdout]   |               ----- in this derive macro expansion                                ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ move occurs because `self.data` has type `__IncompleteArrayField<u8>`, which does not implement the `Copy` trait
[INFO] [stdout]   |
[INFO] [stdout]   = note: `#[derive(Debug)]` triggers a move because taking references to the fields of a packed struct is undefined behaviour
[INFO] [stdout]   = note: this error originates in the derive macro `Debug` (in Nightly builds, run with -Z macro-backtrace for more info)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]  --> /opt/rustwide/target/debug/build/apache-nimble-sys-31e8b6fd6077532c/out/bindings.rs:3:155200
[INFO] [stdout]   |
[INFO] [stdout] 3 | ...)) ; assert_eq ! (unsafe { & (* (:: core :: ptr :: null :: < ble_hci_lc_disconnect_cp > ())) . conn_handle as * const _ as usize } , 0...
[INFO] [stdout]   |                               ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]   |
[INFO] [stdout]   = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]   = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]   = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]  --> /opt/rustwide/target/debug/build/apache-nimble-sys-31e8b6fd6077532c/out/bindings.rs:3:156189
[INFO] [stdout]   |
[INFO] [stdout] 3 | ...) ; assert_eq ! (unsafe { & (* (:: core :: ptr :: null :: < ble_hci_rd_rem_ver_info_cp > ())) . conn_handle as * const _ as usize } , ...
[INFO] [stdout]   |                              ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]   |
[INFO] [stdout]   = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]   = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]   = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]  --> /opt/rustwide/target/debug/build/apache-nimble-sys-31e8b6fd6077532c/out/bindings.rs:3:156956
[INFO] [stdout]   |
[INFO] [stdout] 3 | ...) ; assert_eq ! (unsafe { & (* (:: core :: ptr :: null :: < ble_hci_cb_set_event_mask_cp > ())) . event_mask as * const _ as usize } ,...
[INFO] [stdout]   |                              ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]   |
[INFO] [stdout]   = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]   = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]   = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]  --> /opt/rustwide/target/debug/build/apache-nimble-sys-31e8b6fd6077532c/out/bindings.rs:3:157725
[INFO] [stdout]   |
[INFO] [stdout] 3 | ...)) ; assert_eq ! (unsafe { & (* (:: core :: ptr :: null :: < ble_hci_cb_read_tx_pwr_cp > ())) . conn_handle as * const _ as usize } , ...
[INFO] [stdout]   |                               ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]   |
[INFO] [stdout]   = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]   = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]   = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]  --> /opt/rustwide/target/debug/build/apache-nimble-sys-31e8b6fd6077532c/out/bindings.rs:3:158730
[INFO] [stdout]   |
[INFO] [stdout] 3 | ...)) ; assert_eq ! (unsafe { & (* (:: core :: ptr :: null :: < ble_hci_cb_read_tx_pwr_rp > ())) . conn_handle as * const _ as usize } , ...
[INFO] [stdout]   |                               ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]   |
[INFO] [stdout]   = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]   = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]   = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]  --> /opt/rustwide/target/debug/build/apache-nimble-sys-31e8b6fd6077532c/out/bindings.rs:3:160562
[INFO] [stdout]   |
[INFO] [stdout] 3 | ... ; assert_eq ! (unsafe { & (* (:: core :: ptr :: null :: < ble_hci_cb_host_buf_size_cp > ())) . acl_data_len as * const _ as usize } ,...
[INFO] [stdout]   |                             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]   |
[INFO] [stdout]   = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]   = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]   = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]  --> /opt/rustwide/target/debug/build/apache-nimble-sys-31e8b6fd6077532c/out/bindings.rs:3:161072
[INFO] [stdout]   |
[INFO] [stdout] 3 | ...))) ; assert_eq ! (unsafe { & (* (:: core :: ptr :: null :: < ble_hci_cb_host_buf_size_cp > ())) . acl_num as * const _ as usize } , 3...
[INFO] [stdout]   |                                ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]   |
[INFO] [stdout]   = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]   = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]   = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]  --> /opt/rustwide/target/debug/build/apache-nimble-sys-31e8b6fd6077532c/out/bindings.rs:3:161317
[INFO] [stdout]   |
[INFO] [stdout] 3 | ...))) ; assert_eq ! (unsafe { & (* (:: core :: ptr :: null :: < ble_hci_cb_host_buf_size_cp > ())) . sco_num as * const _ as usize } , 5...
[INFO] [stdout]   |                                ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]   |
[INFO] [stdout]   = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]   = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]   = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]  --> /opt/rustwide/target/debug/build/apache-nimble-sys-31e8b6fd6077532c/out/bindings.rs:3:162134
[INFO] [stdout]   |
[INFO] [stdout] 3 | ...; assert_eq ! (unsafe { & (* (:: core :: ptr :: null :: < ble_hci_cb_host_num_comp_pkts_entry > ())) . handle as * const _ as usize } ...
[INFO] [stdout]   |                            ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]   |
[INFO] [stdout]   = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]   = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]   = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]  --> /opt/rustwide/target/debug/build/apache-nimble-sys-31e8b6fd6077532c/out/bindings.rs:3:162393
[INFO] [stdout]   |
[INFO] [stdout] 3 | ... ; assert_eq ! (unsafe { & (* (:: core :: ptr :: null :: < ble_hci_cb_host_num_comp_pkts_entry > ())) . count as * const _ as usize } ...
[INFO] [stdout]   |                             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]   |
[INFO] [stdout]   = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]   = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]   = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0507]: cannot move out of `self.h` which is behind a shared reference
[INFO] [stdout]  --> /opt/rustwide/target/debug/build/apache-nimble-sys-31e8b6fd6077532c/out/bindings.rs:3:162736
[INFO] [stdout]   |
[INFO] [stdout] 3 | ...e (Debug)] pub struct ble_hci_cb_host_num_comp_pkts_cp { pub handles : u8 , pub h : __IncompleteArrayField < ble_hci_cb_host_num_comp_pkts_entry > , ...
[INFO] [stdout]   |       ----- in this derive macro expansion                                     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ move occurs because `self.h` has type `__IncompleteArrayField<ble_hci_cb_host_num_comp_pkts_entry>`, which does not implement the `Copy` trait
[INFO] [stdout]   |
[INFO] [stdout]   = note: `#[derive(Debug)]` triggers a move because taking references to the fields of a packed struct is undefined behaviour
[INFO] [stdout]   = note: this error originates in the derive macro `Debug` (in Nightly builds, run with -Z macro-backtrace for more info)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]  --> /opt/rustwide/target/debug/build/apache-nimble-sys-31e8b6fd6077532c/out/bindings.rs:3:164265
[INFO] [stdout]   |
[INFO] [stdout] 3 | ... ; assert_eq ! (unsafe { & (* (:: core :: ptr :: null :: < ble_hci_cb_set_event_mask2_cp > ())) . event_mask2 as * const _ as usize } ...
[INFO] [stdout]   |                             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]   |
[INFO] [stdout]   = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]   = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]   = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]  --> /opt/rustwide/target/debug/build/apache-nimble-sys-31e8b6fd6077532c/out/bindings.rs:3:165051
[INFO] [stdout]   |
[INFO] [stdout] 3 | ...; assert_eq ! (unsafe { & (* (:: core :: ptr :: null :: < ble_hci_cb_rd_auth_pyld_tmo_cp > ())) . conn_handle as * const _ as usize } ...
[INFO] [stdout]   |                            ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]   |
[INFO] [stdout]   = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]   = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]   = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]  --> /opt/rustwide/target/debug/build/apache-nimble-sys-31e8b6fd6077532c/out/bindings.rs:3:165855
[INFO] [stdout]   |
[INFO] [stdout] 3 | ...; assert_eq ! (unsafe { & (* (:: core :: ptr :: null :: < ble_hci_cb_rd_auth_pyld_tmo_rp > ())) . conn_handle as * const _ as usize } ...
[INFO] [stdout]   |                            ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]   |
[INFO] [stdout]   = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]   = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]   = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]  --> /opt/rustwide/target/debug/build/apache-nimble-sys-31e8b6fd6077532c/out/bindings.rs:3:166114
[INFO] [stdout]   |
[INFO] [stdout] 3 | ...))) ; assert_eq ! (unsafe { & (* (:: core :: ptr :: null :: < ble_hci_cb_rd_auth_pyld_tmo_rp > ())) . tmo as * const _ as usize } , 2u...
[INFO] [stdout]   |                                ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]   |
[INFO] [stdout]   = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]   = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]   = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]  --> /opt/rustwide/target/debug/build/apache-nimble-sys-31e8b6fd6077532c/out/bindings.rs:3:166902
[INFO] [stdout]   |
[INFO] [stdout] 3 | ...; assert_eq ! (unsafe { & (* (:: core :: ptr :: null :: < ble_hci_cb_wr_auth_pyld_tmo_cp > ())) . conn_handle as * const _ as usize } ...
[INFO] [stdout]   |                            ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]   |
[INFO] [stdout]   = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]   = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]   = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]  --> /opt/rustwide/target/debug/build/apache-nimble-sys-31e8b6fd6077532c/out/bindings.rs:3:167161
[INFO] [stdout]   |
[INFO] [stdout] 3 | ...))) ; assert_eq ! (unsafe { & (* (:: core :: ptr :: null :: < ble_hci_cb_wr_auth_pyld_tmo_cp > ())) . tmo as * const _ as usize } , 2u...
[INFO] [stdout]   |                                ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]   |
[INFO] [stdout]   = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]   = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]   = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]  --> /opt/rustwide/target/debug/build/apache-nimble-sys-31e8b6fd6077532c/out/bindings.rs:3:167933
[INFO] [stdout]   |
[INFO] [stdout] 3 | ...; assert_eq ! (unsafe { & (* (:: core :: ptr :: null :: < ble_hci_cb_wr_auth_pyld_tmo_rp > ())) . conn_handle as * const _ as usize } ...
[INFO] [stdout]   |                            ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]   |
[INFO] [stdout]   = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]   = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]   = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]  --> /opt/rustwide/target/debug/build/apache-nimble-sys-31e8b6fd6077532c/out/bindings.rs:3:169022
[INFO] [stdout]   |
[INFO] [stdout] 3 | ...))) ; assert_eq ! (unsafe { & (* (:: core :: ptr :: null :: < ble_hci_ip_rd_local_ver_rp > ())) . hci_rev as * const _ as usize } , 1u...
[INFO] [stdout]   |                                ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]   |
[INFO] [stdout]   = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]   = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]   = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]  --> /opt/rustwide/target/debug/build/apache-nimble-sys-31e8b6fd6077532c/out/bindings.rs:3:169508
[INFO] [stdout]   |
[INFO] [stdout] 3 | ...) ; assert_eq ! (unsafe { & (* (:: core :: ptr :: null :: < ble_hci_ip_rd_local_ver_rp > ())) . manufacturer as * const _ as usize } ,...
[INFO] [stdout]   |                              ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]   |
[INFO] [stdout]   = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]   = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]   = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]  --> /opt/rustwide/target/debug/build/apache-nimble-sys-31e8b6fd6077532c/out/bindings.rs:3:169761
[INFO] [stdout]   |
[INFO] [stdout] 3 | ...)) ; assert_eq ! (unsafe { & (* (:: core :: ptr :: null :: < ble_hci_ip_rd_local_ver_rp > ())) . lmp_subver as * const _ as usize } , ...
[INFO] [stdout]   |                               ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]   |
[INFO] [stdout]   = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]   = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]   = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]  --> /opt/rustwide/target/debug/build/apache-nimble-sys-31e8b6fd6077532c/out/bindings.rs:3:171311
[INFO] [stdout]   |
[INFO] [stdout] 3 | ...) ; assert_eq ! (unsafe { & (* (:: core :: ptr :: null :: < ble_hci_ip_rd_loc_supp_feat_rp > ())) . features as * const _ as usize } ,...
[INFO] [stdout]   |                              ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]   |
[INFO] [stdout]   = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]   = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]   = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]  --> /opt/rustwide/target/debug/build/apache-nimble-sys-31e8b6fd6077532c/out/bindings.rs:3:172128
[INFO] [stdout]   |
[INFO] [stdout] 3 | ...) ; assert_eq ! (unsafe { & (* (:: core :: ptr :: null :: < ble_hci_ip_rd_buf_size_rp > ())) . acl_data_len as * const _ as usize } , ...
[INFO] [stdout]   |                              ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]   |
[INFO] [stdout]   = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]   = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]   = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]  --> /opt/rustwide/target/debug/build/apache-nimble-sys-31e8b6fd6077532c/out/bindings.rs:3:172630
[INFO] [stdout]   |
[INFO] [stdout] 3 | ...n))) ; assert_eq ! (unsafe { & (* (:: core :: ptr :: null :: < ble_hci_ip_rd_buf_size_rp > ())) . acl_num as * const _ as usize } , 3u...
[INFO] [stdout]   |                                 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]   |
[INFO] [stdout]   = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]   = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]   = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]  --> /opt/rustwide/target/debug/build/apache-nimble-sys-31e8b6fd6077532c/out/bindings.rs:3:172871
[INFO] [stdout]   |
[INFO] [stdout] 3 | ...m))) ; assert_eq ! (unsafe { & (* (:: core :: ptr :: null :: < ble_hci_ip_rd_buf_size_rp > ())) . sco_num as * const _ as usize } , 5u...
[INFO] [stdout]   |                                 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]   |
[INFO] [stdout]   = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]   = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]   = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]  --> /opt/rustwide/target/debug/build/apache-nimble-sys-31e8b6fd6077532c/out/bindings.rs:3:174293
[INFO] [stdout]   |
[INFO] [stdout] 3 | ...si_cp))) ; assert_eq ! (unsafe { & (* (:: core :: ptr :: null :: < ble_hci_rd_rssi_cp > ())) . handle as * const _ as usize } , 0usize...
[INFO] [stdout]   |                                     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]   |
[INFO] [stdout]   = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]   = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]   = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]  --> /opt/rustwide/target/debug/build/apache-nimble-sys-31e8b6fd6077532c/out/bindings.rs:3:174986
[INFO] [stdout]   |
[INFO] [stdout] 3 | ...si_rp))) ; assert_eq ! (unsafe { & (* (:: core :: ptr :: null :: < ble_hci_rd_rssi_rp > ())) . handle as * const _ as usize } , 0usize...
[INFO] [stdout]   |                                     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]   |
[INFO] [stdout]   = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]   = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]   = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]  --> /opt/rustwide/target/debug/build/apache-nimble-sys-31e8b6fd6077532c/out/bindings.rs:3:175948
[INFO] [stdout]   |
[INFO] [stdout] 3 | ...) ; assert_eq ! (unsafe { & (* (:: core :: ptr :: null :: < ble_hci_le_set_event_mask_cp > ())) . event_mask as * const _ as usize } ,...
[INFO] [stdout]   |                              ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]   |
[INFO] [stdout]   = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]   = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]   = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]  --> /opt/rustwide/target/debug/build/apache-nimble-sys-31e8b6fd6077532c/out/bindings.rs:3:176721
[INFO] [stdout]   |
[INFO] [stdout] 3 | ...))) ; assert_eq ! (unsafe { & (* (:: core :: ptr :: null :: < ble_hci_le_rd_buf_size_rp > ())) . data_len as * const _ as usize } , 0u...
[INFO] [stdout]   |                                ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]   |
[INFO] [stdout]   = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]   = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]   = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]  --> /opt/rustwide/target/debug/build/apache-nimble-sys-31e8b6fd6077532c/out/bindings.rs:3:177806
[INFO] [stdout]   |
[INFO] [stdout] 3 | ...)) ; assert_eq ! (unsafe { & (* (:: core :: ptr :: null :: < ble_hci_le_rd_buf_size_v2_rp > ())) . data_len as * const _ as usize } , ...
[INFO] [stdout]   |                               ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]   |
[INFO] [stdout]   = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]   = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]   = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]  --> /opt/rustwide/target/debug/build/apache-nimble-sys-31e8b6fd6077532c/out/bindings.rs:3:178312
[INFO] [stdout]   |
[INFO] [stdout] 3 | ... ; assert_eq ! (unsafe { & (* (:: core :: ptr :: null :: < ble_hci_le_rd_buf_size_v2_rp > ())) . iso_data_len as * const _ as usize } ...
[INFO] [stdout]   |                             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]   |
[INFO] [stdout]   = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]   = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]   = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]  --> /opt/rustwide/target/debug/build/apache-nimble-sys-31e8b6fd6077532c/out/bindings.rs:3:179360
[INFO] [stdout]   |
[INFO] [stdout] 3 | ...) ; assert_eq ! (unsafe { & (* (:: core :: ptr :: null :: < ble_hci_le_rd_loc_supp_feat_rp > ())) . features as * const _ as usize } ,...
[INFO] [stdout]   |                              ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]   |
[INFO] [stdout]   = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]   = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]   = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]  --> /opt/rustwide/target/debug/build/apache-nimble-sys-31e8b6fd6077532c/out/bindings.rs:3:181055
[INFO] [stdout]   |
[INFO] [stdout] 3 | ... ; assert_eq ! (unsafe { & (* (:: core :: ptr :: null :: < ble_hci_le_set_adv_params_cp > ())) . min_interval as * const _ as usize } ...
[INFO] [stdout]   |                             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]   |
[INFO] [stdout]   = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]   = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]   = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]  --> /opt/rustwide/target/debug/build/apache-nimble-sys-31e8b6fd6077532c/out/bindings.rs:3:181312
[INFO] [stdout]   |
[INFO] [stdout] 3 | ... ; assert_eq ! (unsafe { & (* (:: core :: ptr :: null :: < ble_hci_le_set_adv_params_cp > ())) . max_interval as * const _ as usize } ...
[INFO] [stdout]   |                             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]   |
[INFO] [stdout]   = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]   = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]   = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]  --> /opt/rustwide/target/debug/build/apache-nimble-sys-31e8b6fd6077532c/out/bindings.rs:3:187635
[INFO] [stdout]   |
[INFO] [stdout] 3 | ...) ; assert_eq ! (unsafe { & (* (:: core :: ptr :: null :: < ble_hci_le_set_scan_params_cp > ())) . scan_itvl as * const _ as usize } ,...
[INFO] [stdout]   |                              ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]   |
[INFO] [stdout]   = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]   = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]   = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]  --> /opt/rustwide/target/debug/build/apache-nimble-sys-31e8b6fd6077532c/out/bindings.rs:3:187888
[INFO] [stdout]   |
[INFO] [stdout] 3 | ... ; assert_eq ! (unsafe { & (* (:: core :: ptr :: null :: < ble_hci_le_set_scan_params_cp > ())) . scan_window as * const _ as usize } ...
[INFO] [stdout]   |                             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]   |
[INFO] [stdout]   = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]   = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]   = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]  --> /opt/rustwide/target/debug/build/apache-nimble-sys-31e8b6fd6077532c/out/bindings.rs:3:190490
[INFO] [stdout]   |
[INFO] [stdout] 3 | ...))) ; assert_eq ! (unsafe { & (* (:: core :: ptr :: null :: < ble_hci_le_create_conn_cp > ())) . scan_itvl as * const _ as usize } , 0...
[INFO] [stdout]   |                                ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]   |
[INFO] [stdout]   = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]   = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]   = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]  --> /opt/rustwide/target/debug/build/apache-nimble-sys-31e8b6fd6077532c/out/bindings.rs:3:190735
[INFO] [stdout]   |
[INFO] [stdout] 3 | ...)) ; assert_eq ! (unsafe { & (* (:: core :: ptr :: null :: < ble_hci_le_create_conn_cp > ())) . scan_window as * const _ as usize } , ...
[INFO] [stdout]   |                               ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]   |
[INFO] [stdout]   = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]   = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]   = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]  --> /opt/rustwide/target/debug/build/apache-nimble-sys-31e8b6fd6077532c/out/bindings.rs:3:191991
[INFO] [stdout]   |
[INFO] [stdout] 3 | ...) ; assert_eq ! (unsafe { & (* (:: core :: ptr :: null :: < ble_hci_le_create_conn_cp > ())) . min_conn_itvl as * const _ as usize } ,...
[INFO] [stdout]   |                              ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]   |
[INFO] [stdout]   = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]   = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]   = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]  --> /opt/rustwide/target/debug/build/apache-nimble-sys-31e8b6fd6077532c/out/bindings.rs:3:192245
[INFO] [stdout]   |
[INFO] [stdout] 3 | ...) ; assert_eq ! (unsafe { & (* (:: core :: ptr :: null :: < ble_hci_le_create_conn_cp > ())) . max_conn_itvl as * const _ as usize } ,...
[INFO] [stdout]   |                              ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]   |
[INFO] [stdout]   = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]   = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]   = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]  --> /opt/rustwide/target/debug/build/apache-nimble-sys-31e8b6fd6077532c/out/bindings.rs:3:192499
[INFO] [stdout]   |
[INFO] [stdout] 3 | ...) ; assert_eq ! (unsafe { & (* (:: core :: ptr :: null :: < ble_hci_le_create_conn_cp > ())) . conn_latency as * const _ as usize } , ...
[INFO] [stdout]   |                              ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]   |
[INFO] [stdout]   = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]   = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]   = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]  --> /opt/rustwide/target/debug/build/apache-nimble-sys-31e8b6fd6077532c/out/bindings.rs:3:192751
[INFO] [stdout]   |
[INFO] [stdout] 3 | ...ncy))) ; assert_eq ! (unsafe { & (* (:: core :: ptr :: null :: < ble_hci_le_create_conn_cp > ())) . tmo as * const _ as usize } , 19us...
[INFO] [stdout]   |                                   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]   |
[INFO] [stdout]   = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]   = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]   = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]  --> /opt/rustwide/target/debug/build/apache-nimble-sys-31e8b6fd6077532c/out/bindings.rs:3:192985
[INFO] [stdout]   |
[INFO] [stdout] 3 | ...o))) ; assert_eq ! (unsafe { & (* (:: core :: ptr :: null :: < ble_hci_le_create_conn_cp > ())) . min_ce as * const _ as usize } , 21u...
[INFO] [stdout]   |                                 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]   |
[INFO] [stdout]   = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]   = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]   = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]  --> /opt/rustwide/target/debug/build/apache-nimble-sys-31e8b6fd6077532c/out/bindings.rs:3:193225
[INFO] [stdout]   |
[INFO] [stdout] 3 | ...e))) ; assert_eq ! (unsafe { & (* (:: core :: ptr :: null :: < ble_hci_le_create_conn_cp > ())) . max_ce as * const _ as usize } , 23u...
[INFO] [stdout]   |                                 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]   |
[INFO] [stdout]   = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]   = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]   = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]  --> /opt/rustwide/target/debug/build/apache-nimble-sys-31e8b6fd6077532c/out/bindings.rs:3:196918
[INFO] [stdout]   |
[INFO] [stdout] 3 | ...)) ; assert_eq ! (unsafe { & (* (:: core :: ptr :: null :: < ble_hci_le_conn_update_cp > ())) . conn_handle as * const _ as usize } , ...
[INFO] [stdout]   |                               ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]   |
[INFO] [stdout]   = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]   = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]   = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]  --> /opt/rustwide/target/debug/build/apache-nimble-sys-31e8b6fd6077532c/out/bindings.rs:3:197167
[INFO] [stdout]   |
[INFO] [stdout] 3 | ...) ; assert_eq ! (unsafe { & (* (:: core :: ptr :: null :: < ble_hci_le_conn_update_cp > ())) . conn_itvl_min as * const _ as usize } ,...
[INFO] [stdout]   |                              ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]   |
[INFO] [stdout]   = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]   = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]   = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]  --> /opt/rustwide/target/debug/build/apache-nimble-sys-31e8b6fd6077532c/out/bindings.rs:3:197420
[INFO] [stdout]   |
[INFO] [stdout] 3 | ...) ; assert_eq ! (unsafe { & (* (:: core :: ptr :: null :: < ble_hci_le_conn_update_cp > ())) . conn_itvl_max as * const _ as usize } ,...
[INFO] [stdout]   |                              ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]   |
[INFO] [stdout]   = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]   = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]   = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]  --> /opt/rustwide/target/debug/build/apache-nimble-sys-31e8b6fd6077532c/out/bindings.rs:3:197673
[INFO] [stdout]   |
[INFO] [stdout] 3 | ...) ; assert_eq ! (unsafe { & (* (:: core :: ptr :: null :: < ble_hci_le_conn_update_cp > ())) . conn_latency as * const _ as usize } , ...
[INFO] [stdout]   |                              ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]   |
[INFO] [stdout]   = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]   = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]   = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]  --> /opt/rustwide/target/debug/build/apache-nimble-sys-31e8b6fd6077532c/out/bindings.rs:3:197924
[INFO] [stdout]   |
[INFO] [stdout] 3 | ... assert_eq ! (unsafe { & (* (:: core :: ptr :: null :: < ble_hci_le_conn_update_cp > ())) . supervision_timeout as * const _ as usize ...
[INFO] [stdout]   |                           ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]   |
[INFO] [stdout]   = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]   = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]   = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]  --> /opt/rustwide/target/debug/build/apache-nimble-sys-31e8b6fd6077532c/out/bindings.rs:3:198189
[INFO] [stdout]   |
[INFO] [stdout] 3 | ...)) ; assert_eq ! (unsafe { & (* (:: core :: ptr :: null :: < ble_hci_le_conn_update_cp > ())) . min_ce_len as * const _ as usize } , 1...
[INFO] [stdout]   |                               ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]   |
[INFO] [stdout]   = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]   = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]   = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]  --> /opt/rustwide/target/debug/build/apache-nimble-sys-31e8b6fd6077532c/out/bindings.rs:3:198437
[INFO] [stdout]   |
[INFO] [stdout] 3 | ...)) ; assert_eq ! (unsafe { & (* (:: core :: ptr :: null :: < ble_hci_le_conn_update_cp > ())) . max_ce_len as * const _ as usize } , 1...
[INFO] [stdout]   |                               ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]   |
[INFO] [stdout]   = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]   = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]   = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]  --> /opt/rustwide/target/debug/build/apache-nimble-sys-31e8b6fd6077532c/out/bindings.rs:3:199997
[INFO] [stdout]   |
[INFO] [stdout] 3 | ...)) ; assert_eq ! (unsafe { & (* (:: core :: ptr :: null :: < ble_hci_le_rd_chan_map_cp > ())) . conn_handle as * const _ as usize } , ...
[INFO] [stdout]   |                               ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]   |
[INFO] [stdout]   = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]   = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]   = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]  --> /opt/rustwide/target/debug/build/apache-nimble-sys-31e8b6fd6077532c/out/bindings.rs:3:200776
[INFO] [stdout]   |
[INFO] [stdout] 3 | ...)) ; assert_eq ! (unsafe { & (* (:: core :: ptr :: null :: < ble_hci_le_rd_chan_map_rp > ())) . conn_handle as * const _ as usize } , ...
[INFO] [stdout]   |                               ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]   |
[INFO] [stdout]   = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]   = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]   = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]  --> /opt/rustwide/target/debug/build/apache-nimble-sys-31e8b6fd6077532c/out/bindings.rs:3:201767
[INFO] [stdout]   |
[INFO] [stdout] 3 | ...)) ; assert_eq ! (unsafe { & (* (:: core :: ptr :: null :: < ble_hci_le_rd_rem_feat_cp > ())) . conn_handle as * const _ as usize } , ...
[INFO] [stdout]   |                               ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]   |
[INFO] [stdout]   = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]   = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]   = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]  --> /opt/rustwide/target/debug/build/apache-nimble-sys-31e8b6fd6077532c/out/bindings.rs:3:204142
[INFO] [stdout]   |
[INFO] [stdout] 3 | ...p))) ; assert_eq ! (unsafe { & (* (:: core :: ptr :: null :: < ble_hci_le_rand_rp > ())) . random_number as * const _ as usize } , 0us...
[INFO] [stdout]   |                                 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]   |
[INFO] [stdout]   = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]   = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]   = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]  --> /opt/rustwide/target/debug/build/apache-nimble-sys-31e8b6fd6077532c/out/bindings.rs:3:204953
[INFO] [stdout]   |
[INFO] [stdout] 3 | ...) ; assert_eq ! (unsafe { & (* (:: core :: ptr :: null :: < ble_hci_le_start_encrypt_cp > ())) . conn_handle as * const _ as usize } ,...
[INFO] [stdout]   |                              ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]   |
[INFO] [stdout]   = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]   = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]   = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]  --> /opt/rustwide/target/debug/build/apache-nimble-sys-31e8b6fd6077532c/out/bindings.rs:3:205206
[INFO] [stdout]   |
[INFO] [stdout] 3 | ...e))) ; assert_eq ! (unsafe { & (* (:: core :: ptr :: null :: < ble_hci_le_start_encrypt_cp > ())) . rand as * const _ as usize } , 2us...
[INFO] [stdout]   |                                 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]   |
[INFO] [stdout]   = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]   = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]   = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]  --> /opt/rustwide/target/debug/build/apache-nimble-sys-31e8b6fd6077532c/out/bindings.rs:3:205445
[INFO] [stdout]   |
[INFO] [stdout] 3 | ...nd))) ; assert_eq ! (unsafe { & (* (:: core :: ptr :: null :: < ble_hci_le_start_encrypt_cp > ())) . div as * const _ as usize } , 10u...
[INFO] [stdout]   |                                  ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]   |
[INFO] [stdout]   = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]   = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]   = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]  --> /opt/rustwide/target/debug/build/apache-nimble-sys-31e8b6fd6077532c/out/bindings.rs:3:206478
[INFO] [stdout]   |
[INFO] [stdout] 3 | ...; assert_eq ! (unsafe { & (* (:: core :: ptr :: null :: < ble_hci_le_lt_key_req_reply_cp > ())) . conn_handle as * const _ as usize } ...
[INFO] [stdout]   |                            ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]   |
[INFO] [stdout]   = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]   = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]   = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]  --> /opt/rustwide/target/debug/build/apache-nimble-sys-31e8b6fd6077532c/out/bindings.rs:3:207509
[INFO] [stdout]   |
[INFO] [stdout] 3 | ...; assert_eq ! (unsafe { & (* (:: core :: ptr :: null :: < ble_hci_le_lt_key_req_reply_rp > ())) . conn_handle as * const _ as usize } ...
[INFO] [stdout]   |                            ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]   |
[INFO] [stdout]   = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]   = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]   = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]  --> /opt/rustwide/target/debug/build/apache-nimble-sys-31e8b6fd6077532c/out/bindings.rs:3:208321
[INFO] [stdout]   |
[INFO] [stdout] 3 | ...assert_eq ! (unsafe { & (* (:: core :: ptr :: null :: < ble_hci_le_lt_key_req_neg_reply_cp > ())) . conn_handle as * const _ as usize ...
[INFO] [stdout]   |                          ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]   |
[INFO] [stdout]   = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]   = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]   = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]  --> /opt/rustwide/target/debug/build/apache-nimble-sys-31e8b6fd6077532c/out/bindings.rs:3:209141
[INFO] [stdout]   |
[INFO] [stdout] 3 | ...assert_eq ! (unsafe { & (* (:: core :: ptr :: null :: < ble_hci_le_lt_key_req_neg_reply_rp > ())) . conn_handle as * const _ as usize ...
[INFO] [stdout]   |                          ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]   |
[INFO] [stdout]   = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]   = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]   = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]  --> /opt/rustwide/target/debug/build/apache-nimble-sys-31e8b6fd6077532c/out/bindings.rs:3:209920
[INFO] [stdout]   |
[INFO] [stdout] 3 | ...))) ; assert_eq ! (unsafe { & (* (:: core :: ptr :: null :: < ble_hci_le_rd_supp_states_rp > ())) . states as * const _ as usize } , 0...
[INFO] [stdout]   |                                ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]   |
[INFO] [stdout]   = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]   = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]   = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]  --> /opt/rustwide/target/debug/build/apache-nimble-sys-31e8b6fd6077532c/out/bindings.rs:3:212574
[INFO] [stdout]   |
[INFO] [stdout] 3 | ...))) ; assert_eq ! (unsafe { & (* (:: core :: ptr :: null :: < ble_hci_le_test_end_rp > ())) . num_packets as * const _ as usize } , 0u...
[INFO] [stdout]   |                                ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]   |
[INFO] [stdout]   = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]   = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]   = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]  --> /opt/rustwide/target/debug/build/apache-nimble-sys-31e8b6fd6077532c/out/bindings.rs:3:213500
[INFO] [stdout]   |
[INFO] [stdout] 3 | ...; assert_eq ! (unsafe { & (* (:: core :: ptr :: null :: < ble_hci_le_rem_conn_param_rr_cp > ())) . conn_handle as * const _ as usize }...
[INFO] [stdout]   |                            ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]   |
[INFO] [stdout]   = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]   = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]   = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]  --> /opt/rustwide/target/debug/build/apache-nimble-sys-31e8b6fd6077532c/out/bindings.rs:3:213761
[INFO] [stdout]   |
[INFO] [stdout] 3 | ... assert_eq ! (unsafe { & (* (:: core :: ptr :: null :: < ble_hci_le_rem_conn_param_rr_cp > ())) . conn_itvl_min as * const _ as usize ...
[INFO] [stdout]   |                           ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]   |
[INFO] [stdout]   = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]   = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]   = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]  --> /opt/rustwide/target/debug/build/apache-nimble-sys-31e8b6fd6077532c/out/bindings.rs:3:214026
[INFO] [stdout]   |
[INFO] [stdout] 3 | ... assert_eq ! (unsafe { & (* (:: core :: ptr :: null :: < ble_hci_le_rem_conn_param_rr_cp > ())) . conn_itvl_max as * const _ as usize ...
[INFO] [stdout]   |                           ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]   |
[INFO] [stdout]   = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]   = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]   = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]  --> /opt/rustwide/target/debug/build/apache-nimble-sys-31e8b6fd6077532c/out/bindings.rs:3:214291
[INFO] [stdout]   |
[INFO] [stdout] 3 | ... assert_eq ! (unsafe { & (* (:: core :: ptr :: null :: < ble_hci_le_rem_conn_param_rr_cp > ())) . conn_latency as * const _ as usize }...
[INFO] [stdout]   |                           ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]   |
[INFO] [stdout]   = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]   = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]   = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]  --> /opt/rustwide/target/debug/build/apache-nimble-sys-31e8b6fd6077532c/out/bindings.rs:3:214554
[INFO] [stdout]   |
[INFO] [stdout] 3 | ...sert_eq ! (unsafe { & (* (:: core :: ptr :: null :: < ble_hci_le_rem_conn_param_rr_cp > ())) . supervision_timeout as * const _ as usi...
[INFO] [stdout]   |                        ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]   |
[INFO] [stdout]   = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]   = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]   = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]  --> /opt/rustwide/target/debug/build/apache-nimble-sys-31e8b6fd6077532c/out/bindings.rs:3:214831
[INFO] [stdout]   |
[INFO] [stdout] 3 | ...) ; assert_eq ! (unsafe { & (* (:: core :: ptr :: null :: < ble_hci_le_rem_conn_param_rr_cp > ())) . min_ce as * const _ as usize } , ...
[INFO] [stdout]   |                              ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]   |
[INFO] [stdout]   = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]   = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]   = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]  --> /opt/rustwide/target/debug/build/apache-nimble-sys-31e8b6fd6077532c/out/bindings.rs:3:215083
[INFO] [stdout]   |
[INFO] [stdout] 3 | ...) ; assert_eq ! (unsafe { & (* (:: core :: ptr :: null :: < ble_hci_le_rem_conn_param_rr_cp > ())) . max_ce as * const _ as usize } , ...
[INFO] [stdout]   |                              ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]   |
[INFO] [stdout]   = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]   = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]   = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]  --> /opt/rustwide/target/debug/build/apache-nimble-sys-31e8b6fd6077532c/out/bindings.rs:3:215870
[INFO] [stdout]   |
[INFO] [stdout] 3 | ...; assert_eq ! (unsafe { & (* (:: core :: ptr :: null :: < ble_hci_le_rem_conn_param_rr_rp > ())) . conn_handle as * const _ as usize }...
[INFO] [stdout]   |                            ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]   |
[INFO] [stdout]   = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]   = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]   = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]  --> /opt/rustwide/target/debug/build/apache-nimble-sys-31e8b6fd6077532c/out/bindings.rs:3:216696
[INFO] [stdout]   |
[INFO] [stdout] 3 | ... assert_eq ! (unsafe { & (* (:: core :: ptr :: null :: < ble_hci_le_rem_conn_params_nrr_cp > ())) . conn_handle as * const _ as usize ...
[INFO] [stdout]   |                           ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]   |
[INFO] [stdout]   = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]   = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]   = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]  --> /opt/rustwide/target/debug/build/apache-nimble-sys-31e8b6fd6077532c/out/bindings.rs:3:217763
[INFO] [stdout]   |
[INFO] [stdout] 3 | ... assert_eq ! (unsafe { & (* (:: core :: ptr :: null :: < ble_hci_le_rem_conn_params_nrr_rp > ())) . conn_handle as * const _ as usize ...
[INFO] [stdout]   |                           ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]   |
[INFO] [stdout]   = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]   = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]   = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]  --> /opt/rustwide/target/debug/build/apache-nimble-sys-31e8b6fd6077532c/out/bindings.rs:3:218575
[INFO] [stdout]   |
[INFO] [stdout] 3 | ...) ; assert_eq ! (unsafe { & (* (:: core :: ptr :: null :: < ble_hci_le_set_data_len_cp > ())) . conn_handle as * const _ as usize } , ...
[INFO] [stdout]   |                              ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]   |
[INFO] [stdout]   = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]   = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]   = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]  --> /opt/rustwide/target/debug/build/apache-nimble-sys-31e8b6fd6077532c/out/bindings.rs:3:218826
[INFO] [stdout]   |
[INFO] [stdout] 3 | ...)) ; assert_eq ! (unsafe { & (* (:: core :: ptr :: null :: < ble_hci_le_set_data_len_cp > ())) . tx_octets as * const _ as usize } , 2...
[INFO] [stdout]   |                               ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]   |
[INFO] [stdout]   = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]   = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]   = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]  --> /opt/rustwide/target/debug/build/apache-nimble-sys-31e8b6fd6077532c/out/bindings.rs:3:219073
[INFO] [stdout]   |
[INFO] [stdout] 3 | ...))) ; assert_eq ! (unsafe { & (* (:: core :: ptr :: null :: < ble_hci_le_set_data_len_cp > ())) . tx_time as * const _ as usize } , 4u...
[INFO] [stdout]   |                                ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]   |
[INFO] [stdout]   = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]   = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]   = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]  --> /opt/rustwide/target/debug/build/apache-nimble-sys-31e8b6fd6077532c/out/bindings.rs:3:219821
[INFO] [stdout]   |
[INFO] [stdout] 3 | ...) ; assert_eq ! (unsafe { & (* (:: core :: ptr :: null :: < ble_hci_le_set_data_len_rp > ())) . conn_handle as * const _ as usize } , ...
[INFO] [stdout]   |                              ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]   |
[INFO] [stdout]   = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]   = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]   = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]  --> /opt/rustwide/target/debug/build/apache-nimble-sys-31e8b6fd6077532c/out/bindings.rs:3:220651
[INFO] [stdout]   |
[INFO] [stdout] 3 | ...ssert_eq ! (unsafe { & (* (:: core :: ptr :: null :: < ble_hci_le_rd_sugg_def_data_len_rp > ())) . max_tx_octets as * const _ as usize...
[INFO] [stdout]   |                         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]   |
[INFO] [stdout]   = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]   = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]   = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]  --> /opt/rustwide/target/debug/build/apache-nimble-sys-31e8b6fd6077532c/out/bindings.rs:3:220922
[INFO] [stdout]   |
[INFO] [stdout] 3 | ...assert_eq ! (unsafe { & (* (:: core :: ptr :: null :: < ble_hci_le_rd_sugg_def_data_len_rp > ())) . max_tx_time as * const _ as usize ...
[INFO] [stdout]   |                          ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]   |
[INFO] [stdout]   = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]   = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]   = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]  --> /opt/rustwide/target/debug/build/apache-nimble-sys-31e8b6fd6077532c/out/bindings.rs:3:221768
[INFO] [stdout]   |
[INFO] [stdout] 3 | ...ssert_eq ! (unsafe { & (* (:: core :: ptr :: null :: < ble_hci_le_wr_sugg_def_data_len_cp > ())) . max_tx_octets as * const _ as usize...
[INFO] [stdout]   |                         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]   |
[INFO] [stdout]   = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]   = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]   = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]  --> /opt/rustwide/target/debug/build/apache-nimble-sys-31e8b6fd6077532c/out/bindings.rs:3:222039
[INFO] [stdout]   |
[INFO] [stdout] 3 | ...assert_eq ! (unsafe { & (* (:: core :: ptr :: null :: < ble_hci_le_wr_sugg_def_data_len_cp > ())) . max_tx_time as * const _ as usize ...
[INFO] [stdout]   |                          ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]   |
[INFO] [stdout]   = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]   = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]   = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]  --> /opt/rustwide/target/debug/build/apache-nimble-sys-31e8b6fd6077532c/out/bindings.rs:3:231677
[INFO] [stdout]   |
[INFO] [stdout] 3 | ...)) ; assert_eq ! (unsafe { & (* (:: core :: ptr :: null :: < ble_hci_le_set_rpa_tmo_cp > ())) . rpa_timeout as * const _ as usize } , ...
[INFO] [stdout]   |                               ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]   |
[INFO] [stdout]   = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]   = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]   = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]  --> /opt/rustwide/target/debug/build/apache-nimble-sys-31e8b6fd6077532c/out/bindings.rs:3:232527
[INFO] [stdout]   |
[INFO] [stdout] 3 | ... assert_eq ! (unsafe { & (* (:: core :: ptr :: null :: < ble_hci_le_rd_max_data_len_rp > ())) . max_tx_octests as * const _ as usize }...
[INFO] [stdout]   |                           ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]   |
[INFO] [stdout]   = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]   = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]   = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]  --> /opt/rustwide/target/debug/build/apache-nimble-sys-31e8b6fd6077532c/out/bindings.rs:3:232790
[INFO] [stdout]   |
[INFO] [stdout] 3 | ... ; assert_eq ! (unsafe { & (* (:: core :: ptr :: null :: < ble_hci_le_rd_max_data_len_rp > ())) . max_tx_time as * const _ as usize } ...
[INFO] [stdout]   |                             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]   |
[INFO] [stdout]   = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]   = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]   = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]  --> /opt/rustwide/target/debug/build/apache-nimble-sys-31e8b6fd6077532c/out/bindings.rs:3:233047
[INFO] [stdout]   |
[INFO] [stdout] 3 | ... assert_eq ! (unsafe { & (* (:: core :: ptr :: null :: < ble_hci_le_rd_max_data_len_rp > ())) . max_rx_octests as * const _ as usize }...
[INFO] [stdout]   |                           ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]   |
[INFO] [stdout]   = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]   = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]   = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]  --> /opt/rustwide/target/debug/build/apache-nimble-sys-31e8b6fd6077532c/out/bindings.rs:3:233310
[INFO] [stdout]   |
[INFO] [stdout] 3 | ... ; assert_eq ! (unsafe { & (* (:: core :: ptr :: null :: < ble_hci_le_rd_max_data_len_rp > ())) . max_rx_time as * const _ as usize } ...
[INFO] [stdout]   |                             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]   |
[INFO] [stdout]   = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]   = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]   = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]  --> /opt/rustwide/target/debug/build/apache-nimble-sys-31e8b6fd6077532c/out/bindings.rs:3:234036
[INFO] [stdout]   |
[INFO] [stdout] 3 | ...p))) ; assert_eq ! (unsafe { & (* (:: core :: ptr :: null :: < ble_hci_le_rd_phy_cp > ())) . conn_handle as * const _ as usize } , 0us...
[INFO] [stdout]   |                                 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]   |
[INFO] [stdout]   = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]   = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]   = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]  --> /opt/rustwide/target/debug/build/apache-nimble-sys-31e8b6fd6077532c/out/bindings.rs:3:234780
[INFO] [stdout]   |
[INFO] [stdout] 3 | ...p))) ; assert_eq ! (unsafe { & (* (:: core :: ptr :: null :: < ble_hci_le_rd_phy_rp > ())) . conn_handle as * const _ as usize } , 0us...
[INFO] [stdout]   |                                 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]   |
[INFO] [stdout]   = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]   = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]   = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]  --> /opt/rustwide/target/debug/build/apache-nimble-sys-31e8b6fd6077532c/out/bindings.rs:3:237340
[INFO] [stdout]   |
[INFO] [stdout] 3 | ...p))) ; assert_eq ! (unsafe { & (* (:: core :: ptr :: null :: < ble_hci_le_set_phy_cp > ())) . conn_handle as * const _ as usize } , 0u...
[INFO] [stdout]   |                                 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]   |
[INFO] [stdout]   = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]   = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]   = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]  --> /opt/rustwide/target/debug/build/apache-nimble-sys-31e8b6fd6077532c/out/bindings.rs:3:238282
[INFO] [stdout]   |
[INFO] [stdout] 3 | ...s))) ; assert_eq ! (unsafe { & (* (:: core :: ptr :: null :: < ble_hci_le_set_phy_cp > ())) . phy_options as * const _ as usize } , 5u...
[INFO] [stdout]   |                                 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]   |
[INFO] [stdout]   = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]   = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]   = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]  --> /opt/rustwide/target/debug/build/apache-nimble-sys-31e8b6fd6077532c/out/bindings.rs:3:243495
[INFO] [stdout]   |
[INFO] [stdout] 3 | ...) ; assert_eq ! (unsafe { & (* (:: core :: ptr :: null :: < ble_hci_le_set_ext_adv_params_cp > ())) . props as * const _ as usize } , ...
[INFO] [stdout]   |                              ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]   |
[INFO] [stdout]   = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]   = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]   = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0507]: cannot move out of `self.adv_data` which is behind a shared reference
[INFO] [stdout]  --> /opt/rustwide/target/debug/build/apache-nimble-sys-31e8b6fd6077532c/out/bindings.rs:3:248112
[INFO] [stdout]   |
[INFO] [stdout] 3 | ...e (Debug)] pub struct ble_hci_le_set_ext_adv_data_cp { pub adv_handle : u8 , pub operation : u8 , pub fragment_pref : u8 , pub adv_data_len : u8 , pub adv_data : __IncompleteArrayField < u8 > , ...
[INFO] [stdout]   |       ----- in this derive macro expansion                                                                                                            ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ move occurs because `self.adv_data` has type `__IncompleteArrayField<u8>`, which does not implement the `Copy` trait
[INFO] [stdout]   |
[INFO] [stdout]   = note: `#[derive(Debug)]` triggers a move because taking references to the fields of a packed struct is undefined behaviour
[INFO] [stdout]   = note: this error originates in the derive macro `Debug` (in Nightly builds, run with -Z macro-backtrace for more info)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0507]: cannot move out of `self.scan_rsp` which is behind a shared reference
[INFO] [stdout]  --> /opt/rustwide/target/debug/build/apache-nimble-sys-31e8b6fd6077532c/out/bindings.rs:3:250035
[INFO] [stdout]   |
[INFO] [stdout] 3 | ...e (Debug)] pub struct ble_hci_le_set_ext_scan_rsp_data_cp { pub adv_handle : u8 , pub operation : u8 , pub fragment_pref : u8 , pub scan_rsp_len : u8 , pub scan_rsp : __IncompleteArrayField < u8 > , ...
[INFO] [stdout]   |       ----- in this derive macro expansion                                                                                                                 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ move occurs because `self.scan_rsp` has type `__IncompleteArrayField<u8>`, which does not implement the `Copy` trait
[INFO] [stdout]   |
[INFO] [stdout]   = note: `#[derive(Debug)]` triggers a move because taking references to the fields of a packed struct is undefined behaviour
[INFO] [stdout]   = note: this error originates in the derive macro `Debug` (in Nightly builds, run with -Z macro-backtrace for more info)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]  --> /opt/rustwide/target/debug/build/apache-nimble-sys-31e8b6fd6077532c/out/bindings.rs:3:252514
[INFO] [stdout]   |
[INFO] [stdout] 3 | ...dv_handle))) ; assert_eq ! (unsafe { & (* (:: core :: ptr :: null :: < adv_set > ())) . duration as * const _ as usize } , 1usize , co...
[INFO] [stdout]   |                                         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]   |
[INFO] [stdout]   = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]   = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]   = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0507]: cannot move out of `self.sets` which is behind a shared reference
[INFO] [stdout]  --> /opt/rustwide/target/debug/build/apache-nimble-sys-31e8b6fd6077532c/out/bindings.rs:3:253037
[INFO] [stdout]   |
[INFO] [stdout] 3 | ...e (Debug)] pub struct ble_hci_le_set_ext_adv_enable_cp { pub enable : u8 , pub num_sets : u8 , pub sets : __IncompleteArrayField < adv_set > , ...
[INFO] [stdout]   |       ----- in this derive macro expansion                                                        ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ move occurs because `self.sets` has type `__IncompleteArrayField<adv_set>`, which does not implement the `Copy` trait
[INFO] [stdout]   |
[INFO] [stdout]   = note: `#[derive(Debug)]` triggers a move because taking references to the fields of a packed struct is undefined behaviour
[INFO] [stdout]   = note: this error originates in the derive macro `Debug` (in Nightly builds, run with -Z macro-backtrace for more info)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]  --> /opt/rustwide/target/debug/build/apache-nimble-sys-31e8b6fd6077532c/out/bindings.rs:3:254831
[INFO] [stdout]   |
[INFO] [stdout] 3 | ...sert_eq ! (unsafe { & (* (:: core :: ptr :: null :: < ble_hci_le_rd_max_adv_data_len_rp > ())) . max_adv_data_len as * const _ as usiz...
[INFO] [stdout]   |                        ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]   |
[INFO] [stdout]   = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]   = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]   = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]  --> /opt/rustwide/target/debug/build/apache-nimble-sys-31e8b6fd6077532c/out/bindings.rs:3:257568
[INFO] [stdout]   |
[INFO] [stdout] 3 | ...assert_eq ! (unsafe { & (* (:: core :: ptr :: null :: < ble_hci_le_set_periodic_adv_params_cp > ())) . min_itvl as * const _ as usize ...
[INFO] [stdout]   |                          ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]   |
[INFO] [stdout]   = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]   = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]   = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]  --> /opt/rustwide/target/debug/build/apache-nimble-sys-31e8b6fd6077532c/out/bindings.rs:3:257835
[INFO] [stdout]   |
[INFO] [stdout] 3 | ...assert_eq ! (unsafe { & (* (:: core :: ptr :: null :: < ble_hci_le_set_periodic_adv_params_cp > ())) . max_itvl as * const _ as usize ...
[INFO] [stdout]   |                          ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]   |
[INFO] [stdout]   = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]   = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]   = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]  --> /opt/rustwide/target/debug/build/apache-nimble-sys-31e8b6fd6077532c/out/bindings.rs:3:258102
[INFO] [stdout]   |
[INFO] [stdout] 3 | ...; assert_eq ! (unsafe { & (* (:: core :: ptr :: null :: < ble_hci_le_set_periodic_adv_params_cp > ())) . props as * const _ as usize }...
[INFO] [stdout]   |                            ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]   |
[INFO] [stdout]   = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]   = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]   = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0507]: cannot move out of `self.adv_data` which is behind a shared reference
[INFO] [stdout]  --> /opt/rustwide/target/debug/build/apache-nimble-sys-31e8b6fd6077532c/out/bindings.rs:3:258500
[INFO] [stdout]   |
[INFO] [stdout] 3 | ...e (Debug)] pub struct ble_hci_le_set_periodic_adv_data_cp { pub adv_handle : u8 , pub operation : u8 , pub adv_data_len : u8 , pub adv_data : __IncompleteArrayField < u8 > , ...
[INFO] [stdout]   |       ----- in this derive macro expansion                                                                                        ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ move occurs because `self.adv_data` has type `__IncompleteArrayField<u8>`, which does not implement the `Copy` trait
[INFO] [stdout]   |
[INFO] [stdout]   = note: `#[derive(Debug)]` triggers a move because taking references to the fields of a packed struct is undefined behaviour
[INFO] [stdout]   = note: this error originates in the derive macro `Debug` (in Nightly builds, run with -Z macro-backtrace for more info)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]  --> /opt/rustwide/target/debug/build/apache-nimble-sys-31e8b6fd6077532c/out/bindings.rs:3:261837
[INFO] [stdout]   |
[INFO] [stdout] 3 | ... ! (type_))) ; assert_eq ! (unsafe { & (* (:: core :: ptr :: null :: < scan_params > ())) . itvl as * const _ as usize } , 1usize , co...
[INFO] [stdout]   |                                         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]   |
[INFO] [stdout]   = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]   = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]   = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]  --> /opt/rustwide/target/debug/build/apache-nimble-sys-31e8b6fd6077532c/out/bindings.rs:3:262044
[INFO] [stdout]   |
[INFO] [stdout] 3 | ... ! (itvl))) ; assert_eq ! (unsafe { & (* (:: core :: ptr :: null :: < scan_params > ())) . window as * const _ as usize } , 3usize , c...
[INFO] [stdout]   |                                        ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]   |
[INFO] [stdout]   = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]   = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]   = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0507]: cannot move out of `self.scans` which is behind a shared reference
[INFO] [stdout]  --> /opt/rustwide/target/debug/build/apache-nimble-sys-31e8b6fd6077532c/out/bindings.rs:3:262389
[INFO] [stdout]   |
[INFO] [stdout] 3 | ...e (Debug)] pub struct ble_hci_le_set_ext_scan_params_cp { pub own_addr_type : u8 , pub filter_policy : u8 , pub phys : u8 , pub scans : __IncompleteArrayField < scan_params > , ...
[INFO] [stdout]   |       ----- in this derive macro expansion                                                                                     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ move occurs because `self.scans` has type `__IncompleteArrayField<scan_params>`, which does not implement the `Copy` trait
[INFO] [stdout]   |
[INFO] [stdout]   = note: `#[derive(Debug)]` triggers a move because taking references to the fields of a packed struct is undefined behaviour
[INFO] [stdout]   = note: this error originates in the derive macro `Debug` (in Nightly builds, run with -Z macro-backtrace for more info)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]  --> /opt/rustwide/target/debug/build/apache-nimble-sys-31e8b6fd6077532c/out/bindings.rs:3:265045
[INFO] [stdout]   |
[INFO] [stdout] 3 | ...; assert_eq ! (unsafe { & (* (:: core :: ptr :: null :: < ble_hci_le_set_ext_scan_enable_cp > ())) . duration as * const _ as usize } ...
[INFO] [stdout]   |                            ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]   |
[INFO] [stdout]   = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]   = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]   = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]  --> /opt/rustwide/target/debug/build/apache-nimble-sys-31e8b6fd6077532c/out/bindings.rs:3:265304
[INFO] [stdout]   |
[INFO] [stdout] 3 | ... ; assert_eq ! (unsafe { & (* (:: core :: ptr :: null :: < ble_hci_le_set_ext_scan_enable_cp > ())) . period as * const _ as usize } ,...
[INFO] [stdout]   |                             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]   |
[INFO] [stdout]   = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]   = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]   = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]  --> /opt/rustwide/target/debug/build/apache-nimble-sys-31e8b6fd6077532c/out/bindings.rs:3:266144
[INFO] [stdout]   |
[INFO] [stdout] 3 | ..._params))) ; assert_eq ! (unsafe { & (* (:: core :: ptr :: null :: < conn_params > ())) . scan_itvl as * const _ as usize } , 0usize ,...
[INFO] [stdout]   |                                       ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]   |
[INFO] [stdout]   = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]   = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]   = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]  --> /opt/rustwide/target/debug/build/apache-nimble-sys-31e8b6fd6077532c/out/bindings.rs:3:266361
[INFO] [stdout]   |
[INFO] [stdout] 3 | ...n_itvl))) ; assert_eq ! (unsafe { & (* (:: core :: ptr :: null :: < conn_params > ())) . scan_window as * const _ as usize } , 2usize ...
[INFO] [stdout]   |                                      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]   |
[INFO] [stdout]   = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]   = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]   = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]  --> /opt/rustwide/target/debug/build/apache-nimble-sys-31e8b6fd6077532c/out/bindings.rs:3:266582
[INFO] [stdout]   |
[INFO] [stdout] 3 | ...indow))) ; assert_eq ! (unsafe { & (* (:: core :: ptr :: null :: < conn_params > ())) . conn_min_itvl as * const _ as usize } , 4usize...
[INFO] [stdout]   |                                     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]   |
[INFO] [stdout]   = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]   = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]   = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]  --> /opt/rustwide/target/debug/build/apache-nimble-sys-31e8b6fd6077532c/out/bindings.rs:3:266807
[INFO] [stdout]   |
[INFO] [stdout] 3 | ..._itvl))) ; assert_eq ! (unsafe { & (* (:: core :: ptr :: null :: < conn_params > ())) . conn_max_itvl as * const _ as usize } , 6usize...
[INFO] [stdout]   |                                     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]   |
[INFO] [stdout]   = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]   = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]   = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]  --> /opt/rustwide/target/debug/build/apache-nimble-sys-31e8b6fd6077532c/out/bindings.rs:3:267032
[INFO] [stdout]   |
[INFO] [stdout] 3 | ..._itvl))) ; assert_eq ! (unsafe { & (* (:: core :: ptr :: null :: < conn_params > ())) . conn_latency as * const _ as usize } , 8usize ...
[INFO] [stdout]   |                                     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]   |
[INFO] [stdout]   = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]   = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]   = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]  --> /opt/rustwide/target/debug/build/apache-nimble-sys-31e8b6fd6077532c/out/bindings.rs:3:267255
[INFO] [stdout]   |
[INFO] [stdout] 3 | ...cy))) ; assert_eq ! (unsafe { & (* (:: core :: ptr :: null :: < conn_params > ())) . supervision_timeout as * const _ as usize } , 10u...
[INFO] [stdout]   |                                  ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]   |
[INFO] [stdout]   = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]   = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]   = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]  --> /opt/rustwide/target/debug/build/apache-nimble-sys-31e8b6fd6077532c/out/bindings.rs:3:267493
[INFO] [stdout]   |
[INFO] [stdout] 3 | ..._timeout))) ; assert_eq ! (unsafe { & (* (:: core :: ptr :: null :: < conn_params > ())) . min_ce as * const _ as usize } , 12usize , ...
[INFO] [stdout]   |                                        ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]   |
[INFO] [stdout]   = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]   = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]   = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]  --> /opt/rustwide/target/debug/build/apache-nimble-sys-31e8b6fd6077532c/out/bindings.rs:3:267705
[INFO] [stdout]   |
[INFO] [stdout] 3 | ... (min_ce))) ; assert_eq ! (unsafe { & (* (:: core :: ptr :: null :: < conn_params > ())) . max_ce as * const _ as usize } , 14usize , ...
[INFO] [stdout]   |                                        ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]   |
[INFO] [stdout]   = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]   = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]   = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0507]: cannot move out of `self.conn_params` which is behind a shared reference
[INFO] [stdout]  --> /opt/rustwide/target/debug/build/apache-nimble-sys-31e8b6fd6077532c/out/bindings.rs:3:268114
[INFO] [stdout]   |
[INFO] [stdout] 3 | ...e (Debug)] pub struct ble_hci_le_ext_create_conn_cp { pub filter_policy : u8 , pub own_addr_type : u8 , pub peer_addr_type : u8 , pub peer_addr : [u8 ; 6usize] , pub init_phy_mask : u8 , pub conn_params : __IncompleteArrayField < conn_params > , ...
[INFO] [stdout]   |       ----- in this derive macro expansion                                                                                                                                                    ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ move occurs because `self.conn_params` has type `__IncompleteArrayField<conn_params>`, which does not implement the `Copy` trait
[INFO] [stdout]   |
[INFO] [stdout]   = note: `#[derive(Debug)]` triggers a move because taking references to the fields of a packed struct is undefined behaviour
[INFO] [stdout]   = note: this error originates in the derive macro `Debug` (in Nightly builds, run with -Z macro-backtrace for more info)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]  --> /opt/rustwide/target/debug/build/apache-nimble-sys-31e8b6fd6077532c/out/bindings.rs:3:271942
[INFO] [stdout]   |
[INFO] [stdout] 3 | ...; assert_eq ! (unsafe { & (* (:: core :: ptr :: null :: < ble_hci_le_periodic_adv_create_sync_cp > ())) . skip as * const _ as usize }...
[INFO] [stdout]   |                            ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]   |
[INFO] [stdout]   = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]   = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]   = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]  --> /opt/rustwide/target/debug/build/apache-nimble-sys-31e8b6fd6077532c/out/bindings.rs:3:272203
[INFO] [stdout]   |
[INFO] [stdout] 3 | ...sert_eq ! (unsafe { & (* (:: core :: ptr :: null :: < ble_hci_le_periodic_adv_create_sync_cp > ())) . sync_timeout as * const _ as usi...
[INFO] [stdout]   |                        ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]   |
[INFO] [stdout]   = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]   = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]   = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]  --> /opt/rustwide/target/debug/build/apache-nimble-sys-31e8b6fd6077532c/out/bindings.rs:3:273326
[INFO] [stdout]   |
[INFO] [stdout] 3 | ...ssert_eq ! (unsafe { & (* (:: core :: ptr :: null :: < ble_hci_le_periodic_adv_term_sync_cp > ())) . sync_handle as * const _ as usize...
[INFO] [stdout]   |                         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]   |
[INFO] [stdout]   = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]   = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]   = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]  --> /opt/rustwide/target/debug/build/apache-nimble-sys-31e8b6fd6077532c/out/bindings.rs:3:279142
[INFO] [stdout]   |
[INFO] [stdout] 3 | ..._eq ! (unsafe { & (* (:: core :: ptr :: null :: < ble_hci_le_rd_rf_path_compensation_rp > ())) . tx_path_compensation as * const _ as ...
[INFO] [stdout]   |                    ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]   |
[INFO] [stdout]   = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]   = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]   = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]  --> /opt/rustwide/target/debug/build/apache-nimble-sys-31e8b6fd6077532c/out/bindings.rs:3:279433
[INFO] [stdout]   |
[INFO] [stdout] 3 | ..._eq ! (unsafe { & (* (:: core :: ptr :: null :: < ble_hci_le_rd_rf_path_compensation_rp > ())) . rx_path_compensation as * const _ as ...
[INFO] [stdout]   |                    ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]   |
[INFO] [stdout]   = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]   = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]   = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]  --> /opt/rustwide/target/debug/build/apache-nimble-sys-31e8b6fd6077532c/out/bindings.rs:3:280337
[INFO] [stdout]   |
[INFO] [stdout] 3 | ..._eq ! (unsafe { & (* (:: core :: ptr :: null :: < ble_hci_le_wr_rf_path_compensation_cp > ())) . tx_path_compensation as * const _ as ...
[INFO] [stdout]   |                    ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]   |
[INFO] [stdout]   = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]   = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]   = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]  --> /opt/rustwide/target/debug/build/apache-nimble-sys-31e8b6fd6077532c/out/bindings.rs:3:280628
[INFO] [stdout]   |
[INFO] [stdout] 3 | ..._eq ! (unsafe { & (* (:: core :: ptr :: null :: < ble_hci_le_wr_rf_path_compensation_cp > ())) . rx_path_compensation as * const _ as ...
[INFO] [stdout]   |                    ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]   |
[INFO] [stdout]   = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]   = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]   = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]  --> /opt/rustwide/target/debug/build/apache-nimble-sys-31e8b6fd6077532c/out/bindings.rs:3:282894
[INFO] [stdout]   |
[INFO] [stdout] 3 | ...ert_eq ! (unsafe { & (* (:: core :: ptr :: null :: < ble_hci_le_periodic_adv_receive_enable_cp > ())) . sync_handle as * const _ as us...
[INFO] [stdout]   |                       ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]   |
[INFO] [stdout]   = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]   = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]   = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]  --> /opt/rustwide/target/debug/build/apache-nimble-sys-31e8b6fd6077532c/out/bindings.rs:3:284084
[INFO] [stdout]   |
[INFO] [stdout] 3 | ...ert_eq ! (unsafe { & (* (:: core :: ptr :: null :: < ble_hci_le_periodic_adv_sync_transfer_cp > ())) . conn_handle as * const _ as usi...
[INFO] [stdout]   |                       ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]   |
[INFO] [stdout]   = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]   = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]   = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]  --> /opt/rustwide/target/debug/build/apache-nimble-sys-31e8b6fd6077532c/out/bindings.rs:3:284363
[INFO] [stdout]   |
[INFO] [stdout] 3 | ...ert_eq ! (unsafe { & (* (:: core :: ptr :: null :: < ble_hci_le_periodic_adv_sync_transfer_cp > ())) . service_data as * const _ as us...
[INFO] [stdout]   |                       ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]   |
[INFO] [stdout]   = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]   = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]   = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]  --> /opt/rustwide/target/debug/build/apache-nimble-sys-31e8b6fd6077532c/out/bindings.rs:3:284644
[INFO] [stdout]   |
[INFO] [stdout] 3 | ...ert_eq ! (unsafe { & (* (:: core :: ptr :: null :: < ble_hci_le_periodic_adv_sync_transfer_cp > ())) . sync_handle as * const _ as usi...
[INFO] [stdout]   |                       ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]   |
[INFO] [stdout]   = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]   = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]   = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]  --> /opt/rustwide/target/debug/build/apache-nimble-sys-31e8b6fd6077532c/out/bindings.rs:3:285512
[INFO] [stdout]   |
[INFO] [stdout] 3 | ...ert_eq ! (unsafe { & (* (:: core :: ptr :: null :: < ble_hci_le_periodic_adv_sync_transfer_rp > ())) . conn_handle as * const _ as usi...
[INFO] [stdout]   |                       ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]   |
[INFO] [stdout]   = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]   = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]   = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]  --> /opt/rustwide/target/debug/build/apache-nimble-sys-31e8b6fd6077532c/out/bindings.rs:3:286451
[INFO] [stdout]   |
[INFO] [stdout] 3 | ...t_eq ! (unsafe { & (* (:: core :: ptr :: null :: < ble_hci_le_periodic_adv_set_info_transfer_cp > ())) . conn_handle as * const _ as u...
[INFO] [stdout]   |                     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]   |
[INFO] [stdout]   = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]   = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]   = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]  --> /opt/rustwide/target/debug/build/apache-nimble-sys-31e8b6fd6077532c/out/bindings.rs:3:286738
[INFO] [stdout]   |
[INFO] [stdout] 3 | ...t_eq ! (unsafe { & (* (:: core :: ptr :: null :: < ble_hci_le_periodic_adv_set_info_transfer_cp > ())) . service_data as * const _ as ...
[INFO] [stdout]   |                     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]   |
[INFO] [stdout]   = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]   = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]   = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]  --> /opt/rustwide/target/debug/build/apache-nimble-sys-31e8b6fd6077532c/out/bindings.rs:3:287925
[INFO] [stdout]   |
[INFO] [stdout] 3 | ...t_eq ! (unsafe { & (* (:: core :: ptr :: null :: < ble_hci_le_periodic_adv_set_info_transfer_rp > ())) . conn_handle as * const _ as u...
[INFO] [stdout]   |                     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]   |
[INFO] [stdout]   = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]   = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]   = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]  --> /opt/rustwide/target/debug/build/apache-nimble-sys-31e8b6fd6077532c/out/bindings.rs:3:288926
[INFO] [stdout]   |
[INFO] [stdout] 3 | ..._eq ! (unsafe { & (* (:: core :: ptr :: null :: < ble_hci_le_periodic_adv_sync_transfer_params_cp > ())) . conn_handle as * const _ as...
[INFO] [stdout]   |                    ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]   |
[INFO] [stdout]   = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]   = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]   = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]  --> /opt/rustwide/target/debug/build/apache-nimble-sys-31e8b6fd6077532c/out/bindings.rs:3:289498
[INFO] [stdout]   |
[INFO] [stdout] 3 | ...ert_eq ! (unsafe { & (* (:: core :: ptr :: null :: < ble_hci_le_periodic_adv_sync_transfer_params_cp > ())) . skip as * const _ as usi...
[INFO] [stdout]   |                       ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]   |
[INFO] [stdout]   = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]   = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]   = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]  --> /opt/rustwide/target/debug/build/apache-nimble-sys-31e8b6fd6077532c/out/bindings.rs:3:289777
[INFO] [stdout]   |
[INFO] [stdout] 3 | ...eq ! (unsafe { & (* (:: core :: ptr :: null :: < ble_hci_le_periodic_adv_sync_transfer_params_cp > ())) . sync_timeout as * const _ as...
[INFO] [stdout]   |                   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]   |
[INFO] [stdout]   = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]   = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]   = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]  --> /opt/rustwide/target/debug/build/apache-nimble-sys-31e8b6fd6077532c/out/bindings.rs:3:291000
[INFO] [stdout]   |
[INFO] [stdout] 3 | ..._eq ! (unsafe { & (* (:: core :: ptr :: null :: < ble_hci_le_periodic_adv_sync_transfer_params_rp > ())) . conn_handle as * const _ as...
[INFO] [stdout]   |                    ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]   |
[INFO] [stdout]   = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]   = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]   = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]  --> /opt/rustwide/target/debug/build/apache-nimble-sys-31e8b6fd6077532c/out/bindings.rs:3:292326
[INFO] [stdout]   |
[INFO] [stdout] 3 | ...eq ! (unsafe { & (* (:: core :: ptr :: null :: < ble_hci_le_set_default_periodic_sync_transfer_params_cp > ())) . skip as * const _ as...
[INFO] [stdout]   |                   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]   |
[INFO] [stdout]   = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]   = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]   = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]  --> /opt/rustwide/target/debug/build/apache-nimble-sys-31e8b6fd6077532c/out/bindings.rs:3:292621
[INFO] [stdout]   |
[INFO] [stdout] 3 | ... (unsafe { & (* (:: core :: ptr :: null :: < ble_hci_le_set_default_periodic_sync_transfer_params_cp > ())) . sync_timeout as * const ...
[INFO] [stdout]   |               ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]   |
[INFO] [stdout]   = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]   = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]   = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]  --> /opt/rustwide/target/debug/build/apache-nimble-sys-31e8b6fd6077532c/out/bindings.rs:3:293774
[INFO] [stdout]   |
[INFO] [stdout] 3 | ...; assert_eq ! (unsafe { & (* (:: core :: ptr :: null :: < ble_hci_le_request_peer_sca_cp > ())) . conn_handle as * const _ as usize } ...
[INFO] [stdout]   |                            ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]   |
[INFO] [stdout]   = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]   = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]   = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]  --> /opt/rustwide/target/debug/build/apache-nimble-sys-31e8b6fd6077532c/out/bindings.rs:3:295786
[INFO] [stdout]   |
[INFO] [stdout] 3 | ...))) ; assert_eq ! (unsafe { & (* (:: core :: ptr :: null :: < ble_hci_ev_disconn_cmp > ())) . conn_handle as * const _ as usize } , 1u...
[INFO] [stdout]   |                                ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]   |
[INFO] [stdout]   = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]   = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]   = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]  --> /opt/rustwide/target/debug/build/apache-nimble-sys-31e8b6fd6077532c/out/bindings.rs:3:297011
[INFO] [stdout]   |
[INFO] [stdout] 3 | ...) ; assert_eq ! (unsafe { & (* (:: core :: ptr :: null :: < ble_hci_ev_enrypt_chg > ())) . connection_handle as * const _ as usize } ,...
[INFO] [stdout]   |                              ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]   |
[INFO] [stdout]   = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]   = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]   = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]  --> /opt/rustwide/target/debug/build/apache-nimble-sys-31e8b6fd6077532c/out/bindings.rs:3:298360
[INFO] [stdout]   |
[INFO] [stdout] 3 | ...; assert_eq ! (unsafe { & (* (:: core :: ptr :: null :: < ble_hci_ev_rd_rem_ver_info_cmp > ())) . conn_handle as * const _ as usize } ...
[INFO] [stdout]   |                            ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]   |
[INFO] [stdout]   = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]   = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]   = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]  --> /opt/rustwide/target/debug/build/apache-nimble-sys-31e8b6fd6077532c/out/bindings.rs:3:298870
[INFO] [stdout]   |
[INFO] [stdout] 3 | ...; assert_eq ! (unsafe { & (* (:: core :: ptr :: null :: < ble_hci_ev_rd_rem_ver_info_cmp > ())) . manufacturer as * const _ as usize }...
[INFO] [stdout]   |                            ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]   |
[INFO] [stdout]   = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]   = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]   = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]  --> /opt/rustwide/target/debug/build/apache-nimble-sys-31e8b6fd6077532c/out/bindings.rs:3:299131
[INFO] [stdout]   |
[INFO] [stdout] 3 | ... ; assert_eq ! (unsafe { & (* (:: core :: ptr :: null :: < ble_hci_ev_rd_rem_ver_info_cmp > ())) . subversion as * const _ as usize } ...
[INFO] [stdout]   |                             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]   |
[INFO] [stdout]   = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]   = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]   = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0507]: cannot move out of `self.return_params` which is behind a shared reference
[INFO] [stdout]  --> /opt/rustwide/target/debug/build/apache-nimble-sys-31e8b6fd6077532c/out/bindings.rs:3:299510
[INFO] [stdout]   |
[INFO] [stdout] 3 | ...e (Debug)] pub struct ble_hci_ev_command_complete { pub num_packets : u8 , pub opcode : u16 , pub status : u8 , pub return_params : __IncompleteArrayField < u8 > , ...
[INFO] [stdout]   |       ----- in this derive macro expansion                                                                         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ move occurs because `self.return_params` has type `__IncompleteArrayField<u8>`, which does not implement the `Copy` trait
[INFO] [stdout]   |
[INFO] [stdout]   = note: `#[derive(Debug)]` triggers a move because taking references to the fields of a packed struct is undefined behaviour
[INFO] [stdout]   = note: this error originates in the derive macro `Debug` (in Nightly builds, run with -Z macro-backtrace for more info)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]  --> /opt/rustwide/target/debug/build/apache-nimble-sys-31e8b6fd6077532c/out/bindings.rs:3:300225
[INFO] [stdout]   |
[INFO] [stdout] 3 | ...))) ; assert_eq ! (unsafe { & (* (:: core :: ptr :: null :: < ble_hci_ev_command_complete > ())) . opcode as * const _ as usize } , 1u...
[INFO] [stdout]   |                                ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]   |
[INFO] [stdout]   = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]   = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]   = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]  --> /opt/rustwide/target/debug/build/apache-nimble-sys-31e8b6fd6077532c/out/bindings.rs:3:301782
[INFO] [stdout]   |
[INFO] [stdout] 3 | ...) ; assert_eq ! (unsafe { & (* (:: core :: ptr :: null :: < ble_hci_ev_command_complete_nop > ())) . opcode as * const _ as usize } , ...
[INFO] [stdout]   |                              ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]   |
[INFO] [stdout]   = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]   = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]   = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]  --> /opt/rustwide/target/debug/build/apache-nimble-sys-31e8b6fd6077532c/out/bindings.rs:3:303056
[INFO] [stdout]   |
[INFO] [stdout] 3 | ...s))) ; assert_eq ! (unsafe { & (* (:: core :: ptr :: null :: < ble_hci_ev_command_status > ())) . opcode as * const _ as usize } , 2us...
[INFO] [stdout]   |                                 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]   |
[INFO] [stdout]   = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]   = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]   = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]  --> /opt/rustwide/target/debug/build/apache-nimble-sys-31e8b6fd6077532c/out/bindings.rs:3:304394
[INFO] [stdout]   |
[INFO] [stdout] 3 | ... (comp_pkt))) ; assert_eq ! (unsafe { & (* (:: core :: ptr :: null :: < comp_pkt > ())) . handle as * const _ as usize } , 0usize , co...
[INFO] [stdout]   |                                          ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]   |
[INFO] [stdout]   = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]   = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]   = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]  --> /opt/rustwide/target/debug/build/apache-nimble-sys-31e8b6fd6077532c/out/bindings.rs:3:304599
[INFO] [stdout]   |
[INFO] [stdout] 3 | ...! (handle))) ; assert_eq ! (unsafe { & (* (:: core :: ptr :: null :: < comp_pkt > ())) . packets as * const _ as usize } , 2usize , co...
[INFO] [stdout]   |                                         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]   |
[INFO] [stdout]   = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]   = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]   = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0507]: cannot move out of `self.completed` which is behind a shared reference
[INFO] [stdout]  --> /opt/rustwide/target/debug/build/apache-nimble-sys-31e8b6fd6077532c/out/bindings.rs:3:304882
[INFO] [stdout]   |
[INFO] [stdout] 3 | ...erive (Debug)] pub struct ble_hci_ev_num_comp_pkts { pub count : u8 , pub completed : __IncompleteArrayField < comp_pkt > , } # [test]...
[INFO] [stdout]   |           ----- in this derive macro expansion                           ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ move occurs because `self.completed` has type `__IncompleteArrayField<comp_pkt>`, which does not implement the `Copy` trait
[INFO] [stdout]   |
[INFO] [stdout]   = note: `#[derive(Debug)]` triggers a move because taking references to the fields of a packed struct is undefined behaviour
[INFO] [stdout]   = note: this error originates in the derive macro `Debug` (in Nightly builds, run with -Z macro-backtrace for more info)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]  --> /opt/rustwide/target/debug/build/apache-nimble-sys-31e8b6fd6077532c/out/bindings.rs:3:307338
[INFO] [stdout]   |
[INFO] [stdout] 3 | ...) ; assert_eq ! (unsafe { & (* (:: core :: ptr :: null :: < ble_hci_ev_enc_key_refresh > ())) . conn_handle as * const _ as usize } , ...
[INFO] [stdout]   |                              ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]   |
[INFO] [stdout]   = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]   = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]   = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0507]: cannot move out of `self.data` which is behind a shared reference
[INFO] [stdout]  --> /opt/rustwide/target/debug/build/apache-nimble-sys-31e8b6fd6077532c/out/bindings.rs:3:307662
[INFO] [stdout]   |
[INFO] [stdout] 3 | ...] # [derive (Debug)] pub struct ble_hci_ev_le_meta { pub subevent : u8 , pub data : __IncompleteArrayField < u8 > , } # [test] fn bind...
[INFO] [stdout]   |                 ----- in this derive macro expansion                        ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ move occurs because `self.data` has type `__IncompleteArrayField<u8>`, which does not implement the `Copy` trait
[INFO] [stdout]   |
[INFO] [stdout]   = note: `#[derive(Debug)]` triggers a move because taking references to the fields of a packed struct is undefined behaviour
[INFO] [stdout]   = note: this error originates in the derive macro `Debug` (in Nightly builds, run with -Z macro-backtrace for more info)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]  --> /opt/rustwide/target/debug/build/apache-nimble-sys-31e8b6fd6077532c/out/bindings.rs:3:309013
[INFO] [stdout]   |
[INFO] [stdout] 3 | ...)) ; assert_eq ! (unsafe { & (* (:: core :: ptr :: null :: < ble_hci_ev_auth_pyld_tmo > ())) . conn_handle as * const _ as usize } , 0...
[INFO] [stdout]   |                               ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]   |
[INFO] [stdout]   = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]   = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]   = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0507]: cannot move out of `self.data` which is behind a shared reference
[INFO] [stdout]  --> /opt/rustwide/target/debug/build/apache-nimble-sys-31e8b6fd6077532c/out/bindings.rs:3:309332
[INFO] [stdout]   |
[INFO] [stdout] 3 | ...] # [derive (Debug)] pub struct ble_hci_ev_vendor_debug { pub id : u8 , pub data : __IncompleteArrayField < u8 > , } # [test] fn bindg...
[INFO] [stdout]   |                 ----- in this derive macro expansion                       ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ move occurs because `self.data` has type `__IncompleteArrayField<u8>`, which does not implement the `Copy` trait
[INFO] [stdout]   |
[INFO] [stdout]   = note: `#[derive(Debug)]` triggers a move because taking references to the fields of a packed struct is undefined behaviour
[INFO] [stdout]   = note: this error originates in the derive macro `Debug` (in Nightly builds, run with -Z macro-backtrace for more info)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]  --> /opt/rustwide/target/debug/build/apache-nimble-sys-31e8b6fd6077532c/out/bindings.rs:3:311497
[INFO] [stdout]   |
[INFO] [stdout] 3 | ... assert_eq ! (unsafe { & (* (:: core :: ptr :: null :: < ble_hci_ev_le_subev_conn_complete > ())) . conn_handle as * const _ as usize ...
[INFO] [stdout]   |                           ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]   |
[INFO] [stdout]   = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]   = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]   = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]  --> /opt/rustwide/target/debug/build/apache-nimble-sys-31e8b6fd6077532c/out/bindings.rs:3:312545
[INFO] [stdout]   |
[INFO] [stdout] 3 | ...; assert_eq ! (unsafe { & (* (:: core :: ptr :: null :: < ble_hci_ev_le_subev_conn_complete > ())) . conn_itvl as * const _ as usize }...
[INFO] [stdout]   |                            ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]   |
[INFO] [stdout]   = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]   = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]   = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]  --> /opt/rustwide/target/debug/build/apache-nimble-sys-31e8b6fd6077532c/out/bindings.rs:3:312807
[INFO] [stdout]   |
[INFO] [stdout] 3 | ...assert_eq ! (unsafe { & (* (:: core :: ptr :: null :: < ble_hci_ev_le_subev_conn_complete > ())) . conn_latency as * const _ as usize ...
[INFO] [stdout]   |                          ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]   |
[INFO] [stdout]   = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]   = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]   = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]  --> /opt/rustwide/target/debug/build/apache-nimble-sys-31e8b6fd6077532c/out/bindings.rs:3:313075
[INFO] [stdout]   |
[INFO] [stdout] 3 | ...ert_eq ! (unsafe { & (* (:: core :: ptr :: null :: < ble_hci_ev_le_subev_conn_complete > ())) . supervision_timeout as * const _ as us...
[INFO] [stdout]   |                       ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]   |
[INFO] [stdout]   = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]   = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]   = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0507]: cannot move out of `self.data` which is behind a shared reference
[INFO] [stdout]  --> /opt/rustwide/target/debug/build/apache-nimble-sys-31e8b6fd6077532c/out/bindings.rs:3:313737
[INFO] [stdout]   |
[INFO] [stdout] 3 | ...e (Debug)] pub struct adv_report { pub type_ : u8 , pub addr_type : u8 , pub addr : [u8 ; 6usize] , pub data_len : u8 , pub data : __IncompleteArrayField < u8 > , ...
[INFO] [stdout]   |       ----- in this derive macro expansion                                                                                 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ move occurs because `self.data` has type `__IncompleteArrayField<u8>`, which does not implement the `Copy` trait
[INFO] [stdout]   |
[INFO] [stdout]   = note: `#[derive(Debug)]` triggers a move because taking references to the fields of a packed struct is undefined behaviour
[INFO] [stdout]   = note: this error originates in the derive macro `Debug` (in Nightly builds, run with -Z macro-backtrace for more info)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0507]: cannot move out of `self.reports` which is behind a shared reference
[INFO] [stdout]  --> /opt/rustwide/target/debug/build/apache-nimble-sys-31e8b6fd6077532c/out/bindings.rs:3:315257
[INFO] [stdout]   |
[INFO] [stdout] 3 | ...e (Debug)] pub struct ble_hci_ev_le_subev_adv_rpt { pub subev_code : u8 , pub num_reports : u8 , pub reports : __IncompleteArrayField < adv_report > , ...
[INFO] [stdout]   |       ----- in this derive macro expansion                                                          ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ move occurs because `self.reports` has type `__IncompleteArrayField<adv_report>`, which does not implement the `Copy` trait
[INFO] [stdout]   |
[INFO] [stdout]   = note: `#[derive(Debug)]` triggers a move because taking references to the fields of a packed struct is undefined behaviour
[INFO] [stdout]   = note: this error originates in the derive macro `Debug` (in Nightly builds, run with -Z macro-backtrace for more info)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]  --> /opt/rustwide/target/debug/build/apache-nimble-sys-31e8b6fd6077532c/out/bindings.rs:3:317695
[INFO] [stdout]   |
[INFO] [stdout] 3 | ...ssert_eq ! (unsafe { & (* (:: core :: ptr :: null :: < ble_hci_ev_le_subev_conn_upd_complete > ())) . conn_handle as * const _ as usiz...
[INFO] [stdout]   |                         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]   |
[INFO] [stdout]   = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]   = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]   = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]  --> /opt/rustwide/target/debug/build/apache-nimble-sys-31e8b6fd6077532c/out/bindings.rs:3:317968
[INFO] [stdout]   |
[INFO] [stdout] 3 | ...assert_eq ! (unsafe { & (* (:: core :: ptr :: null :: < ble_hci_ev_le_subev_conn_upd_complete > ())) . conn_itvl as * const _ as usize...
[INFO] [stdout]   |                          ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]   |
[INFO] [stdout]   = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]   = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]   = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]  --> /opt/rustwide/target/debug/build/apache-nimble-sys-31e8b6fd6077532c/out/bindings.rs:3:318237
[INFO] [stdout]   |
[INFO] [stdout] 3 | ...sert_eq ! (unsafe { & (* (:: core :: ptr :: null :: < ble_hci_ev_le_subev_conn_upd_complete > ())) . conn_latency as * const _ as usiz...
[INFO] [stdout]   |                        ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]   |
[INFO] [stdout]   = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]   = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]   = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]  --> /opt/rustwide/target/debug/build/apache-nimble-sys-31e8b6fd6077532c/out/bindings.rs:3:318512
[INFO] [stdout]   |
[INFO] [stdout] 3 | ...t_eq ! (unsafe { & (* (:: core :: ptr :: null :: < ble_hci_ev_le_subev_conn_upd_complete > ())) . supervision_timeout as * const _ as ...
[INFO] [stdout]   |                     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]   |
[INFO] [stdout]   = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]   = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]   = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]  --> /opt/rustwide/target/debug/build/apache-nimble-sys-31e8b6fd6077532c/out/bindings.rs:3:319968
[INFO] [stdout]   |
[INFO] [stdout] 3 | ...ssert_eq ! (unsafe { & (* (:: core :: ptr :: null :: < ble_hci_ev_le_subev_rd_rem_used_feat > ())) . conn_handle as * const _ as usize...
[INFO] [stdout]   |                         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]   |
[INFO] [stdout]   = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]   = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]   = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]  --> /opt/rustwide/target/debug/build/apache-nimble-sys-31e8b6fd6077532c/out/bindings.rs:3:321346
[INFO] [stdout]   |
[INFO] [stdout] 3 | ...; assert_eq ! (unsafe { & (* (:: core :: ptr :: null :: < ble_hci_ev_le_subev_lt_key_req > ())) . conn_handle as * const _ as usize } ...
[INFO] [stdout]   |                            ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]   |
[INFO] [stdout]   = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]   = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]   = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]  --> /opt/rustwide/target/debug/build/apache-nimble-sys-31e8b6fd6077532c/out/bindings.rs:3:321605
[INFO] [stdout]   |
[INFO] [stdout] 3 | ...))) ; assert_eq ! (unsafe { & (* (:: core :: ptr :: null :: < ble_hci_ev_le_subev_lt_key_req > ())) . rand as * const _ as usize } , 3...
[INFO] [stdout]   |                                ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]   |
[INFO] [stdout]   = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]   = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]   = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]  --> /opt/rustwide/target/debug/build/apache-nimble-sys-31e8b6fd6077532c/out/bindings.rs:3:321850
[INFO] [stdout]   |
[INFO] [stdout] 3 | ...))) ; assert_eq ! (unsafe { & (* (:: core :: ptr :: null :: < ble_hci_ev_le_subev_lt_key_req > ())) . div as * const _ as usize } , 11...
[INFO] [stdout]   |                                ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]   |
[INFO] [stdout]   = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]   = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]   = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]  --> /opt/rustwide/target/debug/build/apache-nimble-sys-31e8b6fd6077532c/out/bindings.rs:3:323057
[INFO] [stdout]   |
[INFO] [stdout] 3 | ...sert_eq ! (unsafe { & (* (:: core :: ptr :: null :: < ble_hci_ev_le_subev_rem_conn_param_req > ())) . conn_handle as * const _ as usiz...
[INFO] [stdout]   |                        ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]   |
[INFO] [stdout]   = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]   = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]   = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]  --> /opt/rustwide/target/debug/build/apache-nimble-sys-31e8b6fd6077532c/out/bindings.rs:3:323332
[INFO] [stdout]   |
[INFO] [stdout] 3 | ...sert_eq ! (unsafe { & (* (:: core :: ptr :: null :: < ble_hci_ev_le_subev_rem_conn_param_req > ())) . min_interval as * const _ as usi...
[INFO] [stdout]   |                        ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]   |
[INFO] [stdout]   = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]   = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]   = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]  --> /opt/rustwide/target/debug/build/apache-nimble-sys-31e8b6fd6077532c/out/bindings.rs:3:323609
[INFO] [stdout]   |
[INFO] [stdout] 3 | ...sert_eq ! (unsafe { & (* (:: core :: ptr :: null :: < ble_hci_ev_le_subev_rem_conn_param_req > ())) . max_interval as * const _ as usi...
[INFO] [stdout]   |                        ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]   |
[INFO] [stdout]   = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]   = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]   = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]  --> /opt/rustwide/target/debug/build/apache-nimble-sys-31e8b6fd6077532c/out/bindings.rs:3:323886
[INFO] [stdout]   |
[INFO] [stdout] 3 | ...assert_eq ! (unsafe { & (* (:: core :: ptr :: null :: < ble_hci_ev_le_subev_rem_conn_param_req > ())) . latency as * const _ as usize ...
[INFO] [stdout]   |                          ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]   |
[INFO] [stdout]   = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]   = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]   = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]  --> /opt/rustwide/target/debug/build/apache-nimble-sys-31e8b6fd6077532c/out/bindings.rs:3:324153
[INFO] [stdout]   |
[INFO] [stdout] 3 | ...assert_eq ! (unsafe { & (* (:: core :: ptr :: null :: < ble_hci_ev_le_subev_rem_conn_param_req > ())) . timeout as * const _ as usize ...
[INFO] [stdout]   |                          ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]   |
[INFO] [stdout]   = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]   = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]   = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]  --> /opt/rustwide/target/debug/build/apache-nimble-sys-31e8b6fd6077532c/out/bindings.rs:3:325345
[INFO] [stdout]   |
[INFO] [stdout] 3 | ... assert_eq ! (unsafe { & (* (:: core :: ptr :: null :: < ble_hci_ev_le_subev_data_len_chg > ())) . conn_handle as * const _ as usize }...
[INFO] [stdout]   |                           ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]   |
[INFO] [stdout]   = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]   = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]   = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]  --> /opt/rustwide/target/debug/build/apache-nimble-sys-31e8b6fd6077532c/out/bindings.rs:3:325608
[INFO] [stdout]   |
[INFO] [stdout] 3 | ...assert_eq ! (unsafe { & (* (:: core :: ptr :: null :: < ble_hci_ev_le_subev_data_len_chg > ())) . max_tx_octets as * const _ as usize ...
[INFO] [stdout]   |                          ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]   |
[INFO] [stdout]   = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]   = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]   = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]  --> /opt/rustwide/target/debug/build/apache-nimble-sys-31e8b6fd6077532c/out/bindings.rs:3:325875
[INFO] [stdout]   |
[INFO] [stdout] 3 | ... assert_eq ! (unsafe { & (* (:: core :: ptr :: null :: < ble_hci_ev_le_subev_data_len_chg > ())) . max_tx_time as * const _ as usize }...
[INFO] [stdout]   |                           ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]   |
[INFO] [stdout]   = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]   = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]   = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]  --> /opt/rustwide/target/debug/build/apache-nimble-sys-31e8b6fd6077532c/out/bindings.rs:3:326138
[INFO] [stdout]   |
[INFO] [stdout] 3 | ...assert_eq ! (unsafe { & (* (:: core :: ptr :: null :: < ble_hci_ev_le_subev_data_len_chg > ())) . max_rx_octets as * const _ as usize ...
[INFO] [stdout]   |                          ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]   |
[INFO] [stdout]   = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]   = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]   = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]  --> /opt/rustwide/target/debug/build/apache-nimble-sys-31e8b6fd6077532c/out/bindings.rs:3:326405
[INFO] [stdout]   |
[INFO] [stdout] 3 | ... assert_eq ! (unsafe { & (* (:: core :: ptr :: null :: < ble_hci_ev_le_subev_data_len_chg > ())) . max_rx_time as * const _ as usize }...
[INFO] [stdout]   |                           ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]   |
[INFO] [stdout]   = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]   = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]   = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]  --> /opt/rustwide/target/debug/build/apache-nimble-sys-31e8b6fd6077532c/out/bindings.rs:3:330903
[INFO] [stdout]   |
[INFO] [stdout] 3 | ...ssert_eq ! (unsafe { & (* (:: core :: ptr :: null :: < ble_hci_ev_le_subev_enh_conn_complete > ())) . conn_handle as * const _ as usiz...
[INFO] [stdout]   |                         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]   |
[INFO] [stdout]   = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]   = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]   = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]  --> /opt/rustwide/target/debug/build/apache-nimble-sys-31e8b6fd6077532c/out/bindings.rs:3:332521
[INFO] [stdout]   |
[INFO] [stdout] 3 | ...assert_eq ! (unsafe { & (* (:: core :: ptr :: null :: < ble_hci_ev_le_subev_enh_conn_complete > ())) . conn_itvl as * const _ as usize...
[INFO] [stdout]   |                          ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]   |
[INFO] [stdout]   = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]   = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]   = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]  --> /opt/rustwide/target/debug/build/apache-nimble-sys-31e8b6fd6077532c/out/bindings.rs:3:332791
[INFO] [stdout]   |
[INFO] [stdout] 3 | ...sert_eq ! (unsafe { & (* (:: core :: ptr :: null :: < ble_hci_ev_le_subev_enh_conn_complete > ())) . conn_latency as * const _ as usiz...
[INFO] [stdout]   |                        ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]   |
[INFO] [stdout]   = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]   = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]   = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]  --> /opt/rustwide/target/debug/build/apache-nimble-sys-31e8b6fd6077532c/out/bindings.rs:3:333067
[INFO] [stdout]   |
[INFO] [stdout] 3 | ...t_eq ! (unsafe { & (* (:: core :: ptr :: null :: < ble_hci_ev_le_subev_enh_conn_complete > ())) . supervision_timeout as * const _ as ...
[INFO] [stdout]   |                     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]   |
[INFO] [stdout]   = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]   = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]   = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0507]: cannot move out of `self.reports` which is behind a shared reference
[INFO] [stdout]  --> /opt/rustwide/target/debug/build/apache-nimble-sys-31e8b6fd6077532c/out/bindings.rs:3:335593
[INFO] [stdout]   |
[INFO] [stdout] 3 | ...e (Debug)] pub struct ble_hci_ev_le_subev_direct_adv_rpt { pub subev_code : u8 , pub num_reports : u8 , pub reports : __IncompleteArrayField < dir_adv_report > , ...
[INFO] [stdout]   |       ----- in this derive macro expansion                                                                 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ move occurs because `self.reports` has type `__IncompleteArrayField<dir_adv_report>`, which does not implement the `Copy` trait
[INFO] [stdout]   |
[INFO] [stdout]   = note: `#[derive(Debug)]` triggers a move because taking references to the fields of a packed struct is undefined behaviour
[INFO] [stdout]   = note: this error originates in the derive macro `Debug` (in Nightly builds, run with -Z macro-backtrace for more info)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]  --> /opt/rustwide/target/debug/build/apache-nimble-sys-31e8b6fd6077532c/out/bindings.rs:3:338088
[INFO] [stdout]   |
[INFO] [stdout] 3 | ...sert_eq ! (unsafe { & (* (:: core :: ptr :: null :: < ble_hci_ev_le_subev_phy_update_complete > ())) . conn_handle as * const _ as usi...
[INFO] [stdout]   |                        ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]   |
[INFO] [stdout]   = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]   = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]   = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0507]: cannot move out of `self.data` which is behind a shared reference
[INFO] [stdout]  --> /opt/rustwide/target/debug/build/apache-nimble-sys-31e8b6fd6077532c/out/bindings.rs:3:339208
[INFO] [stdout]   |
[INFO] [stdout] 3 | ...e (Debug)] pub struct ext_adv_report { pub evt_type : u16 , pub addr_type : u8 , pub addr : [u8 ; 6usize] , pub pri_phy : u8 , pub sec_phy : u8 , pub sid : u8 , pub tx_power : i8 , pub rssi : i8 , pub periodic_itvl : u16 , pub dir_addr_type : u8 , pub dir_addr : [u8 ; 6usize] , pub data_len : u8 , pub data : __IncompleteArrayField < u8 > , ...
[INFO] [stdout]   |       ----- in this derive macro expansion                                                                                                                                                                                                                                                                    ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ move occurs because `self.data` has type `__IncompleteArrayField<u8>`, which does not implement the `Copy` trait
[INFO] [stdout]   |
[INFO] [stdout]   = note: `#[derive(Debug)]` triggers a move because taking references to the fields of a packed struct is undefined behaviour
[INFO] [stdout]   = note: this error originates in the derive macro `Debug` (in Nightly builds, run with -Z macro-backtrace for more info)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]  --> /opt/rustwide/target/debug/build/apache-nimble-sys-31e8b6fd6077532c/out/bindings.rs:3:339597
[INFO] [stdout]   |
[INFO] [stdout] 3 | ...report))) ; assert_eq ! (unsafe { & (* (:: core :: ptr :: null :: < ext_adv_report > ())) . evt_type as * const _ as usize } , 0usize ...
[INFO] [stdout]   |                                      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]   |
[INFO] [stdout]   = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]   = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]   = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]  --> /opt/rustwide/target/debug/build/apache-nimble-sys-31e8b6fd6077532c/out/bindings.rs:3:341341
[INFO] [stdout]   |
[INFO] [stdout] 3 | ...ssi))) ; assert_eq ! (unsafe { & (* (:: core :: ptr :: null :: < ext_adv_report > ())) . periodic_itvl as * const _ as usize } , 14usi...
[INFO] [stdout]   |                                   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]   |
[INFO] [stdout]   = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]   = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]   = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0507]: cannot move out of `self.reports` which is behind a shared reference
[INFO] [stdout]  --> /opt/rustwide/target/debug/build/apache-nimble-sys-31e8b6fd6077532c/out/bindings.rs:3:342574
[INFO] [stdout]   |
[INFO] [stdout] 3 | ...e (Debug)] pub struct ble_hci_ev_le_subev_ext_adv_rpt { pub subev_code : u8 , pub num_reports : u8 , pub reports : __IncompleteArrayField < ext_adv_report > , ...
[INFO] [stdout]   |       ----- in this derive macro expansion                                                              ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ move occurs because `self.reports` has type `__IncompleteArrayField<ext_adv_report>`, which does not implement the `Copy` trait
[INFO] [stdout]   |
[INFO] [stdout]   = note: `#[derive(Debug)]` triggers a move because taking references to the fields of a packed struct is undefined behaviour
[INFO] [stdout]   = note: this error originates in the derive macro `Debug` (in Nightly builds, run with -Z macro-backtrace for more info)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]  --> /opt/rustwide/target/debug/build/apache-nimble-sys-31e8b6fd6077532c/out/bindings.rs:3:345165
[INFO] [stdout]   |
[INFO] [stdout] 3 | ...rt_eq ! (unsafe { & (* (:: core :: ptr :: null :: < ble_hci_ev_le_subev_periodic_adv_sync_estab > ())) . sync_handle as * const _ as u...
[INFO] [stdout]   |                      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]   |
[INFO] [stdout]   = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]   = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]   = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]  --> /opt/rustwide/target/debug/build/apache-nimble-sys-31e8b6fd6077532c/out/bindings.rs:3:346561
[INFO] [stdout]   |
[INFO] [stdout] 3 | ...ert_eq ! (unsafe { & (* (:: core :: ptr :: null :: < ble_hci_ev_le_subev_periodic_adv_sync_estab > ())) . interval as * const _ as usi...
[INFO] [stdout]   |                       ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]   |
[INFO] [stdout]   = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]   = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]   = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0507]: cannot move out of `self.data` which is behind a shared reference
[INFO] [stdout]  --> /opt/rustwide/target/debug/build/apache-nimble-sys-31e8b6fd6077532c/out/bindings.rs:3:347327
[INFO] [stdout]   |
[INFO] [stdout] 3 | ...e (Debug)] pub struct ble_hci_ev_le_subev_periodic_adv_rpt { pub subev_code : u8 , pub sync_handle : u16 , pub tx_power : i8 , pub rssi : i8 , pub cte_type : u8 , pub data_status : u8 , pub data_len : u8 , pub data : __IncompleteArrayField < u8 > , ...
[INFO] [stdout]   |       ----- in this derive macro expansion                                                                                                                                                                       ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ move occurs because `self.data` has type `__IncompleteArrayField<u8>`, which does not implement the `Copy` trait
[INFO] [stdout]   |
[INFO] [stdout]   = note: `#[derive(Debug)]` triggers a move because taking references to the fields of a packed struct is undefined behaviour
[INFO] [stdout]   = note: this error originates in the derive macro `Debug` (in Nightly builds, run with -Z macro-backtrace for more info)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]  --> /opt/rustwide/target/debug/build/apache-nimble-sys-31e8b6fd6077532c/out/bindings.rs:3:348094
[INFO] [stdout]   |
[INFO] [stdout] 3 | ...ssert_eq ! (unsafe { & (* (:: core :: ptr :: null :: < ble_hci_ev_le_subev_periodic_adv_rpt > ())) . sync_handle as * const _ as usize...
[INFO] [stdout]   |                         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]   |
[INFO] [stdout]   = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]   = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]   = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]  --> /opt/rustwide/target/debug/build/apache-nimble-sys-31e8b6fd6077532c/out/bindings.rs:3:350849
[INFO] [stdout]   |
[INFO] [stdout] 3 | ...rt_eq ! (unsafe { & (* (:: core :: ptr :: null :: < ble_hci_ev_le_subev_periodic_adv_sync_lost > ())) . sync_handle as * const _ as us...
[INFO] [stdout]   |                      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]   |
[INFO] [stdout]   = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]   = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]   = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]  --> /opt/rustwide/target/debug/build/apache-nimble-sys-31e8b6fd6077532c/out/bindings.rs:3:353404
[INFO] [stdout]   |
[INFO] [stdout] 3 | ...sert_eq ! (unsafe { & (* (:: core :: ptr :: null :: < ble_hci_ev_le_subev_adv_set_terminated > ())) . conn_handle as * const _ as usiz...
[INFO] [stdout]   |                        ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]   |
[INFO] [stdout]   = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]   = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]   = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]  --> /opt/rustwide/target/debug/build/apache-nimble-sys-31e8b6fd6077532c/out/bindings.rs:3:356474
[INFO] [stdout]   |
[INFO] [stdout] 3 | ... assert_eq ! (unsafe { & (* (:: core :: ptr :: null :: < ble_hci_ev_le_subev_chan_sel_alg > ())) . conn_handle as * const _ as usize }...
[INFO] [stdout]   |                           ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]   |
[INFO] [stdout]   = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]   = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]   = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]  --> /opt/rustwide/target/debug/build/apache-nimble-sys-31e8b6fd6077532c/out/bindings.rs:3:358393
[INFO] [stdout]   |
[INFO] [stdout] 3 | ..._eq ! (unsafe { & (* (:: core :: ptr :: null :: < ble_hci_ev_le_subev_periodic_adv_sync_transfer > ())) . conn_handle as * const _ as ...
[INFO] [stdout]   |                    ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]   |
[INFO] [stdout]   = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]   = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]   = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]  --> /opt/rustwide/target/debug/build/apache-nimble-sys-31e8b6fd6077532c/out/bindings.rs:3:358684
[INFO] [stdout]   |
[INFO] [stdout] 3 | ..._eq ! (unsafe { & (* (:: core :: ptr :: null :: < ble_hci_ev_le_subev_periodic_adv_sync_transfer > ())) . service_data as * const _ as...
[INFO] [stdout]   |                    ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]   |
[INFO] [stdout]   = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]   = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]   = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]  --> /opt/rustwide/target/debug/build/apache-nimble-sys-31e8b6fd6077532c/out/bindings.rs:3:358977
[INFO] [stdout]   |
[INFO] [stdout] 3 | ..._eq ! (unsafe { & (* (:: core :: ptr :: null :: < ble_hci_ev_le_subev_periodic_adv_sync_transfer > ())) . sync_handle as * const _ as ...
[INFO] [stdout]   |                    ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]   |
[INFO] [stdout]   = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]   = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]   = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]  --> /opt/rustwide/target/debug/build/apache-nimble-sys-31e8b6fd6077532c/out/bindings.rs:3:360404
[INFO] [stdout]   |
[INFO] [stdout] 3 | ...rt_eq ! (unsafe { & (* (:: core :: ptr :: null :: < ble_hci_ev_le_subev_periodic_adv_sync_transfer > ())) . interval as * const _ as u...
[INFO] [stdout]   |                      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]   |
[INFO] [stdout]   = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]   = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]   = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]  --> /opt/rustwide/target/debug/build/apache-nimble-sys-31e8b6fd6077532c/out/bindings.rs:3:362453
[INFO] [stdout]   |
[INFO] [stdout] 3 | ...assert_eq ! (unsafe { & (* (:: core :: ptr :: null :: < ble_hci_ev_le_subev_cis_established > ())) . cis_handle as * const _ as usize ...
[INFO] [stdout]   |                          ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]   |
[INFO] [stdout]   = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]   = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]   = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]  --> /opt/rustwide/target/debug/build/apache-nimble-sys-31e8b6fd6077532c/out/bindings.rs:3:365668
[INFO] [stdout]   |
[INFO] [stdout] 3 | ...ssert_eq ! (unsafe { & (* (:: core :: ptr :: null :: < ble_hci_ev_le_subev_cis_established > ())) . max_pdu_mtos as * const _ as usize...
[INFO] [stdout]   |                         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]   |
[INFO] [stdout]   = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]   = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]   = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]  --> /opt/rustwide/target/debug/build/apache-nimble-sys-31e8b6fd6077532c/out/bindings.rs:3:365940
[INFO] [stdout]   |
[INFO] [stdout] 3 | ...ssert_eq ! (unsafe { & (* (:: core :: ptr :: null :: < ble_hci_ev_le_subev_cis_established > ())) . max_pdu_stom as * const _ as usize...
[INFO] [stdout]   |                         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]   |
[INFO] [stdout]   = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]   = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]   = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]  --> /opt/rustwide/target/debug/build/apache-nimble-sys-31e8b6fd6077532c/out/bindings.rs:3:366212
[INFO] [stdout]   |
[INFO] [stdout] 3 | ...ssert_eq ! (unsafe { & (* (:: core :: ptr :: null :: < ble_hci_ev_le_subev_cis_established > ())) . iso_interval as * const _ as usize...
[INFO] [stdout]   |                         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]   |
[INFO] [stdout]   = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]   = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]   = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]  --> /opt/rustwide/target/debug/build/apache-nimble-sys-31e8b6fd6077532c/out/bindings.rs:3:367359
[INFO] [stdout]   |
[INFO] [stdout] 3 | ...; assert_eq ! (unsafe { & (* (:: core :: ptr :: null :: < ble_hci_ev_le_subev_cis_request > ())) . conn_handle as * const _ as usize }...
[INFO] [stdout]   |                            ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]   |
[INFO] [stdout]   = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]   = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]   = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]  --> /opt/rustwide/target/debug/build/apache-nimble-sys-31e8b6fd6077532c/out/bindings.rs:3:367620
[INFO] [stdout]   |
[INFO] [stdout] 3 | ...; assert_eq ! (unsafe { & (* (:: core :: ptr :: null :: < ble_hci_ev_le_subev_cis_request > ())) . cis_handle as * const _ as usize } ...
[INFO] [stdout]   |                            ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]   |
[INFO] [stdout]   = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]   = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]   = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0507]: cannot move out of `self.bis` which is behind a shared reference
[INFO] [stdout]  --> /opt/rustwide/target/debug/build/apache-nimble-sys-31e8b6fd6077532c/out/bindings.rs:3:368725
[INFO] [stdout]   |
[INFO] [stdout] 3 | ...e (Debug)] pub struct ble_hci_ev_le_subev_big_complete { pub subev_code : u8 , pub status : u8 , pub big_handle : u8 , pub big_sync_delay : [u8 ; 3usize] , pub transport_latency : [u8 ; 3usize] , pub phy : u8 , pub nse : u8 , pub bn : u8 , pub pto : u8 , pub irc : u8 , pub max_pdu : u16 , pub iso_interval : u16 , pub bis_cnt : u8 , pub bis : __IncompleteArrayField < u16 > , ...
[INFO] [stdout]   |       ----- in this derive macro expansion                                                                                                                                                                                                                                                                                                       ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ move occurs because `self.bis` has type `__IncompleteArrayField<u16>`, which does not implement the `Copy` trait
[INFO] [stdout]   |
[INFO] [stdout]   = note: `#[derive(Debug)]` triggers a move because taking references to the fields of a packed struct is undefined behaviour
[INFO] [stdout]   = note: this error originates in the derive macro `Debug` (in Nightly builds, run with -Z macro-backtrace for more info)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]  --> /opt/rustwide/target/debug/build/apache-nimble-sys-31e8b6fd6077532c/out/bindings.rs:3:371760
[INFO] [stdout]   |
[INFO] [stdout] 3 | ... ; assert_eq ! (unsafe { & (* (:: core :: ptr :: null :: < ble_hci_ev_le_subev_big_complete > ())) . max_pdu as * const _ as usize } ,...
[INFO] [stdout]   |                             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]   |
[INFO] [stdout]   = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]   = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]   = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]  --> /opt/rustwide/target/debug/build/apache-nimble-sys-31e8b6fd6077532c/out/bindings.rs:3:372016
[INFO] [stdout]   |
[INFO] [stdout] 3 | ... assert_eq ! (unsafe { & (* (:: core :: ptr :: null :: < ble_hci_ev_le_subev_big_complete > ())) . iso_interval as * const _ as usize ...
[INFO] [stdout]   |                           ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]   |
[INFO] [stdout]   = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]   = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]   = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]  --> /opt/rustwide/target/debug/build/apache-nimble-sys-31e8b6fd6077532c/out/bindings.rs:3:372538
[INFO] [stdout]   |
[INFO] [stdout] 3 | ...)) ; assert_eq ! (unsafe { & (* (:: core :: ptr :: null :: < ble_hci_ev_le_subev_big_complete > ())) . bis as * const _ as usize } , 1...
[INFO] [stdout]   |                               ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]   |
[INFO] [stdout]   = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]   = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]   = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0507]: cannot move out of `self.bis_handles` which is behind a shared reference
[INFO] [stdout]  --> /opt/rustwide/target/debug/build/apache-nimble-sys-31e8b6fd6077532c/out/bindings.rs:3:374560
[INFO] [stdout]   |
[INFO] [stdout] 3 | ...e (Debug)] pub struct ble_hci_ev_le_subev_big_sync_established { pub subev_code : u8 , pub status : u8 , pub big_handle : u8 , pub transport_latency : [u8 ; 3usize] , pub nse : u8 , pub bn : u8 , pub pto : u8 , pub irc : u8 , pub max_pdu : u16 , pub iso_interval : u16 , pub bis_cnt : u8 , pub bis_handles : __IncompleteArrayField < u16 > , ...
[INFO] [stdout]   |       ----- in this derive macro expansion                                                                                                                                                                                                                                                           ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ move occurs because `self.bis_handles` has type `__IncompleteArrayField<u16>`, which does not implement the `Copy` trait
[INFO] [stdout]   |
[INFO] [stdout]   = note: `#[derive(Debug)]` triggers a move because taking references to the fields of a packed struct is undefined behaviour
[INFO] [stdout]   = note: this error originates in the derive macro `Debug` (in Nightly builds, run with -Z macro-backtrace for more info)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]  --> /opt/rustwide/target/debug/build/apache-nimble-sys-31e8b6fd6077532c/out/bindings.rs:3:377251
[INFO] [stdout]   |
[INFO] [stdout] 3 | ...ssert_eq ! (unsafe { & (* (:: core :: ptr :: null :: < ble_hci_ev_le_subev_big_sync_established > ())) . max_pdu as * const _ as usize...
[INFO] [stdout]   |                         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]   |
[INFO] [stdout]   = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]   = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]   = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]  --> /opt/rustwide/target/debug/build/apache-nimble-sys-31e8b6fd6077532c/out/bindings.rs:3:377523
[INFO] [stdout]   |
[INFO] [stdout] 3 | ...ert_eq ! (unsafe { & (* (:: core :: ptr :: null :: < ble_hci_ev_le_subev_big_sync_established > ())) . iso_interval as * const _ as us...
[INFO] [stdout]   |                       ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]   |
[INFO] [stdout]   = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]   = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]   = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]  --> /opt/rustwide/target/debug/build/apache-nimble-sys-31e8b6fd6077532c/out/bindings.rs:3:378077
[INFO] [stdout]   |
[INFO] [stdout] 3 | ...ert_eq ! (unsafe { & (* (:: core :: ptr :: null :: < ble_hci_ev_le_subev_big_sync_established > ())) . bis_handles as * const _ as usi...
[INFO] [stdout]   |                       ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]   |
[INFO] [stdout]   = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]   = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]   = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]  --> /opt/rustwide/target/debug/build/apache-nimble-sys-31e8b6fd6077532c/out/bindings.rs:3:380883
[INFO] [stdout]   |
[INFO] [stdout] 3 | ...ssert_eq ! (unsafe { & (* (:: core :: ptr :: null :: < ble_hci_ev_le_subev_peer_sca_complete > ())) . conn_handle as * const _ as usiz...
[INFO] [stdout]   |                         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]   |
[INFO] [stdout]   = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]   = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]   = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]  --> /opt/rustwide/target/debug/build/apache-nimble-sys-31e8b6fd6077532c/out/bindings.rs:3:382520
[INFO] [stdout]   |
[INFO] [stdout] 3 | ...sert_eq ! (unsafe { & (* (:: core :: ptr :: null :: < ble_hci_ev_le_subev_biginfo_adv_report > ())) . sync_handle as * const _ as usiz...
[INFO] [stdout]   |                        ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]   |
[INFO] [stdout]   = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]   = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]   = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]  --> /opt/rustwide/target/debug/build/apache-nimble-sys-31e8b6fd6077532c/out/bindings.rs:3:383321
[INFO] [stdout]   |
[INFO] [stdout] 3 | ...sert_eq ! (unsafe { & (* (:: core :: ptr :: null :: < ble_hci_ev_le_subev_biginfo_adv_report > ())) . iso_interval as * const _ as usi...
[INFO] [stdout]   |                        ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]   |
[INFO] [stdout]   = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]   = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]   = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]  --> /opt/rustwide/target/debug/build/apache-nimble-sys-31e8b6fd6077532c/out/bindings.rs:3:384373
[INFO] [stdout]   |
[INFO] [stdout] 3 | ...assert_eq ! (unsafe { & (* (:: core :: ptr :: null :: < ble_hci_ev_le_subev_biginfo_adv_report > ())) . max_pdu as * const _ as usize ...
[INFO] [stdout]   |                          ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]   |
[INFO] [stdout]   = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]   = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]   = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]  --> /opt/rustwide/target/debug/build/apache-nimble-sys-31e8b6fd6077532c/out/bindings.rs:3:384919
[INFO] [stdout]   |
[INFO] [stdout] 3 | ...assert_eq ! (unsafe { & (* (:: core :: ptr :: null :: < ble_hci_ev_le_subev_biginfo_adv_report > ())) . max_sdu as * const _ as usize ...
[INFO] [stdout]   |                          ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]   |
[INFO] [stdout]   = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]   = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]   = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: aborting due to 220 previous errors; 6 warnings emitted
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] Some errors have detailed explanations: E0507, E0793.
[INFO] [stdout] 
[INFO] [stdout] For more information about an error, try `rustc --explain E0507`.
[INFO] [stdout] 
[INFO] [stderr] The following warnings were emitted during compilation:
[INFO] [stderr] 
[INFO] [stderr] warning: apache-nimble-sys@0.0.1: Compiler version doesn't include clang or GCC: "cc" "--version"
[INFO] [stderr] 
[INFO] [stderr] error: could not compile `apache-nimble-sys` (lib test) due to 221 previous errors; 6 warnings emitted
[INFO] running `Command { std: "docker" "inspect" "3fa6fcd04c060e906d8f9ddb7b164f9038eb7c418570c80b3917aafc590fb911", kill_on_drop: false }`
[INFO] running `Command { std: "docker" "rm" "-f" "3fa6fcd04c060e906d8f9ddb7b164f9038eb7c418570c80b3917aafc590fb911", kill_on_drop: false }`
[INFO] [stdout] 3fa6fcd04c060e906d8f9ddb7b164f9038eb7c418570c80b3917aafc590fb911
[INFO] checking apache-nimble-sys-0.0.1 against try#bfe97fcae016881ad333f0ff8cea2cadb9cf136c for pr-121848
[INFO] extracting crate apache-nimble-sys 0.0.1 into /workspace/builds/worker-5-tc2/source
[INFO] validating manifest of crates.io crate apache-nimble-sys 0.0.1 on toolchain bfe97fcae016881ad333f0ff8cea2cadb9cf136c
[INFO] running `Command { std: CARGO_HOME="/workspace/cargo-home" RUSTUP_HOME="/workspace/rustup-home" "/workspace/cargo-home/bin/cargo" "+bfe97fcae016881ad333f0ff8cea2cadb9cf136c" "metadata" "--manifest-path" "Cargo.toml" "--no-deps", kill_on_drop: false }`
[INFO] started tweaking crates.io crate apache-nimble-sys 0.0.1
[INFO] finished tweaking crates.io crate apache-nimble-sys 0.0.1
[INFO] tweaked toml for crates.io crate apache-nimble-sys 0.0.1 written to /workspace/builds/worker-5-tc2/source/Cargo.toml
[INFO] running `Command { std: CARGO_HOME="/workspace/cargo-home" RUSTUP_HOME="/workspace/rustup-home" "/workspace/cargo-home/bin/cargo" "+bfe97fcae016881ad333f0ff8cea2cadb9cf136c" "generate-lockfile" "--manifest-path" "Cargo.toml", kill_on_drop: false }`
[INFO] [stderr]     Updating crates.io index
[INFO] running `Command { std: CARGO_HOME="/workspace/cargo-home" RUSTUP_HOME="/workspace/rustup-home" "/workspace/cargo-home/bin/cargo" "+bfe97fcae016881ad333f0ff8cea2cadb9cf136c" "fetch" "--manifest-path" "Cargo.toml", kill_on_drop: false }`
[INFO] [stderr] warning: the cargo feature `resolver` has been stabilized in the 1.51 release and is no longer necessary to be listed in the manifest
[INFO] [stderr]   See https://doc.rust-lang.org/nightly/cargo/reference/resolver.html#resolver-versions for more information about using this feature.
[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:2788e3201cd34a07e3172128adcd8b3090168a8e3bcc40d7c032b9dda1df7d1c" "/opt/rustwide/cargo-home/bin/cargo" "+bfe97fcae016881ad333f0ff8cea2cadb9cf136c" "metadata" "--no-deps" "--format-version=1", kill_on_drop: false }`
[INFO] [stdout] cbc5f78ce91469b812fbbad55893a572671ade0b55baf0239a6e5a49bf38862b
[INFO] running `Command { std: "docker" "start" "-a" "cbc5f78ce91469b812fbbad55893a572671ade0b55baf0239a6e5a49bf38862b", kill_on_drop: false }`
[INFO] running `Command { std: "docker" "inspect" "cbc5f78ce91469b812fbbad55893a572671ade0b55baf0239a6e5a49bf38862b", kill_on_drop: false }`
[INFO] running `Command { std: "docker" "rm" "-f" "cbc5f78ce91469b812fbbad55893a572671ade0b55baf0239a6e5a49bf38862b", kill_on_drop: false }`
[INFO] [stdout] cbc5f78ce91469b812fbbad55893a572671ade0b55baf0239a6e5a49bf38862b
[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:2788e3201cd34a07e3172128adcd8b3090168a8e3bcc40d7c032b9dda1df7d1c" "/opt/rustwide/cargo-home/bin/cargo" "+bfe97fcae016881ad333f0ff8cea2cadb9cf136c" "check" "--frozen" "--all" "--all-targets" "--message-format=json", kill_on_drop: false }`
[INFO] [stdout] da4bd2c83464f286d81844822263e857b1bb3c11d0dfa6f65646767fd925d190
[INFO] running `Command { std: "docker" "start" "-a" "da4bd2c83464f286d81844822263e857b1bb3c11d0dfa6f65646767fd925d190", kill_on_drop: false }`
[INFO] [stderr] warning: the cargo feature `resolver` has been stabilized in the 1.51 release and is no longer necessary to be listed in the manifest
[INFO] [stderr]   See https://doc.rust-lang.org/nightly/cargo/reference/resolver.html#resolver-versions for more information about using this feature.
[INFO] [stderr]    Compiling libc v0.2.153
[INFO] [stderr]    Compiling memchr v2.7.1
[INFO] [stderr]    Compiling glob v0.3.1
[INFO] [stderr]    Compiling cc v1.0.90
[INFO] [stderr]    Compiling proc-macro2 v1.0.78
[INFO] [stderr]    Compiling unicode-width v0.1.11
[INFO] [stderr]    Compiling quick-error v1.2.3
[INFO] [stderr]    Compiling bindgen v0.53.3
[INFO] [stderr]    Compiling termcolor v1.4.1
[INFO] [stderr]    Compiling nom v5.1.3
[INFO] [stderr]    Compiling log v0.4.21
[INFO] [stderr]    Compiling vec_map v0.8.2
[INFO] [stderr]    Compiling bitflags v1.3.2
[INFO] [stderr]    Compiling ansi_term v0.12.1
[INFO] [stderr]    Compiling strsim v0.8.0
[INFO] [stderr]    Compiling cfg-if v0.1.10
[INFO] [stderr]    Compiling peeking_take_while v0.1.2
[INFO] [stderr]    Compiling humantime v1.3.0
[INFO] [stderr]    Compiling textwrap v0.11.0
[INFO] [stderr]    Compiling rustc-hash v1.1.0
[INFO] [stderr]    Compiling shlex v0.1.1
[INFO] [stderr]    Compiling lazy_static v1.4.0
[INFO] [stderr]    Compiling lazycell v1.3.0
[INFO] [stderr]     Checking cty v0.2.2
[INFO] [stderr]    Compiling clang-sys v0.29.3
[INFO] [stderr]    Compiling aho-corasick v1.1.2
[INFO] [stderr]    Compiling atty v0.2.14
[INFO] [stderr]    Compiling which v3.1.1
[INFO] [stderr]     Checking cstr_core v0.2.6
[INFO] [stderr]    Compiling clap v2.34.0
[INFO] [stderr]    Compiling quote v1.0.35
[INFO] [stderr]    Compiling libloading v0.5.2
[INFO] [stderr]    Compiling regex-automata v0.4.6
[INFO] [stderr]    Compiling cexpr v0.4.0
[INFO] [stderr]    Compiling regex v1.10.3
[INFO] [stderr]    Compiling env_logger v0.7.1
[INFO] [stderr]    Compiling apache-nimble-sys v0.0.1 (/opt/rustwide/workdir)
[INFO] [stderr] warning: apache-nimble-sys@0.0.1: Compiler version doesn't include clang or GCC: "cc" "--version"
[INFO] [stdout] warning: unused variable: `ptr`
[INFO] [stdout]  --> src/lib.rs:8:17
[INFO] [stdout]   |
[INFO] [stdout] 8 |     pub fn free(ptr: *mut cty::c_void) {}
[INFO] [stdout]   |                 ^^^ help: if this is intentional, prefix it with an underscore: `_ptr`
[INFO] [stdout]   |
[INFO] [stdout]   = note: `#[warn(unused_variables)]` on by default
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: unused variable: `amt`
[INFO] [stdout]   --> src/lib.rs:11:19
[INFO] [stdout]    |
[INFO] [stdout] 11 |     pub fn malloc(amt: cty::size_t) -> *mut cty::c_void {
[INFO] [stdout]    |                   ^^^ help: if this is intentional, prefix it with an underscore: `_amt`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: unused variable: `file`
[INFO] [stdout]   --> src/lib.rs:16:26
[INFO] [stdout]    |
[INFO] [stdout] 16 |     pub fn __assert_func(file: *const char, line: usize, func: *const char, expr: *const char) {
[INFO] [stdout]    |                          ^^^^ help: if this is intentional, prefix it with an underscore: `_file`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: unused variable: `line`
[INFO] [stdout]   --> src/lib.rs:16:45
[INFO] [stdout]    |
[INFO] [stdout] 16 |     pub fn __assert_func(file: *const char, line: usize, func: *const char, expr: *const char) {
[INFO] [stdout]    |                                             ^^^^ help: if this is intentional, prefix it with an underscore: `_line`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: unused variable: `func`
[INFO] [stdout]   --> src/lib.rs:16:58
[INFO] [stdout]    |
[INFO] [stdout] 16 |     pub fn __assert_func(file: *const char, line: usize, func: *const char, expr: *const char) {
[INFO] [stdout]    |                                                          ^^^^ help: if this is intentional, prefix it with an underscore: `_func`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: unused variable: `expr`
[INFO] [stdout]   --> src/lib.rs:16:77
[INFO] [stdout]    |
[INFO] [stdout] 16 |     pub fn __assert_func(file: *const char, line: usize, func: *const char, expr: *const char) {
[INFO] [stdout]    |                                                                             ^^^^ help: if this is intentional, prefix it with an underscore: `_expr`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0507]: cannot move out of `self.data` which is behind a shared reference
[INFO] [stdout]  --> /opt/rustwide/target/debug/build/apache-nimble-sys-31e8b6fd6077532c/out/bindings.rs:3:152615
[INFO] [stdout]   |
[INFO] [stdout] 3 | ...[derive (Debug)] pub struct ble_hci_cmd { pub opcode : u16 , pub length : u8 , pub data : __IncompleteArrayField < u8 > , } # [test] f...
[INFO] [stdout]   |             ----- in this derive macro expansion                                  ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ move occurs because `self.data` has type `__IncompleteArrayField<u8>`, which does not implement the `Copy` trait
[INFO] [stdout]   |
[INFO] [stdout]   = note: `#[derive(Debug)]` triggers a move because taking references to the fields of a packed struct is undefined behaviour
[INFO] [stdout]   = note: this error originates in the derive macro `Debug` (in Nightly builds, run with -Z macro-backtrace for more info)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0507]: cannot move out of `self.data` which is behind a shared reference
[INFO] [stdout]  --> /opt/rustwide/target/debug/build/apache-nimble-sys-31e8b6fd6077532c/out/bindings.rs:3:153698
[INFO] [stdout]   |
[INFO] [stdout] 3 | ...# [derive (Debug)] pub struct ble_hci_ev { pub opcode : u8 , pub length : u8 , pub data : __IncompleteArrayField < u8 > , } # [test] f...
[INFO] [stdout]   |               ----- in this derive macro expansion                                ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ move occurs because `self.data` has type `__IncompleteArrayField<u8>`, which does not implement the `Copy` trait
[INFO] [stdout]   |
[INFO] [stdout]   = note: `#[derive(Debug)]` triggers a move because taking references to the fields of a packed struct is undefined behaviour
[INFO] [stdout]   = note: this error originates in the derive macro `Debug` (in Nightly builds, run with -Z macro-backtrace for more info)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0507]: cannot move out of `self.h` which is behind a shared reference
[INFO] [stdout]  --> /opt/rustwide/target/debug/build/apache-nimble-sys-31e8b6fd6077532c/out/bindings.rs:3:162736
[INFO] [stdout]   |
[INFO] [stdout] 3 | ...e (Debug)] pub struct ble_hci_cb_host_num_comp_pkts_cp { pub handles : u8 , pub h : __IncompleteArrayField < ble_hci_cb_host_num_comp_pkts_entry > , ...
[INFO] [stdout]   |       ----- in this derive macro expansion                                     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ move occurs because `self.h` has type `__IncompleteArrayField<ble_hci_cb_host_num_comp_pkts_entry>`, which does not implement the `Copy` trait
[INFO] [stdout]   |
[INFO] [stdout]   = note: `#[derive(Debug)]` triggers a move because taking references to the fields of a packed struct is undefined behaviour
[INFO] [stdout]   = note: this error originates in the derive macro `Debug` (in Nightly builds, run with -Z macro-backtrace for more info)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0507]: cannot move out of `self.adv_data` which is behind a shared reference
[INFO] [stdout]  --> /opt/rustwide/target/debug/build/apache-nimble-sys-31e8b6fd6077532c/out/bindings.rs:3:248112
[INFO] [stdout]   |
[INFO] [stdout] 3 | ...e (Debug)] pub struct ble_hci_le_set_ext_adv_data_cp { pub adv_handle : u8 , pub operation : u8 , pub fragment_pref : u8 , pub adv_data_len : u8 , pub adv_data : __IncompleteArrayField < u8 > , ...
[INFO] [stdout]   |       ----- in this derive macro expansion                                                                                                            ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ move occurs because `self.adv_data` has type `__IncompleteArrayField<u8>`, which does not implement the `Copy` trait
[INFO] [stdout]   |
[INFO] [stdout]   = note: `#[derive(Debug)]` triggers a move because taking references to the fields of a packed struct is undefined behaviour
[INFO] [stdout]   = note: this error originates in the derive macro `Debug` (in Nightly builds, run with -Z macro-backtrace for more info)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0507]: cannot move out of `self.scan_rsp` which is behind a shared reference
[INFO] [stdout]  --> /opt/rustwide/target/debug/build/apache-nimble-sys-31e8b6fd6077532c/out/bindings.rs:3:250035
[INFO] [stdout]   |
[INFO] [stdout] 3 | ...e (Debug)] pub struct ble_hci_le_set_ext_scan_rsp_data_cp { pub adv_handle : u8 , pub operation : u8 , pub fragment_pref : u8 , pub scan_rsp_len : u8 , pub scan_rsp : __IncompleteArrayField < u8 > , ...
[INFO] [stdout]   |       ----- in this derive macro expansion                                                                                                                 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ move occurs because `self.scan_rsp` has type `__IncompleteArrayField<u8>`, which does not implement the `Copy` trait
[INFO] [stdout]   |
[INFO] [stdout]   = note: `#[derive(Debug)]` triggers a move because taking references to the fields of a packed struct is undefined behaviour
[INFO] [stdout]   = note: this error originates in the derive macro `Debug` (in Nightly builds, run with -Z macro-backtrace for more info)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0507]: cannot move out of `self.sets` which is behind a shared reference
[INFO] [stdout]  --> /opt/rustwide/target/debug/build/apache-nimble-sys-31e8b6fd6077532c/out/bindings.rs:3:253037
[INFO] [stdout]   |
[INFO] [stdout] 3 | ...e (Debug)] pub struct ble_hci_le_set_ext_adv_enable_cp { pub enable : u8 , pub num_sets : u8 , pub sets : __IncompleteArrayField < adv_set > , ...
[INFO] [stdout]   |       ----- in this derive macro expansion                                                        ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ move occurs because `self.sets` has type `__IncompleteArrayField<adv_set>`, which does not implement the `Copy` trait
[INFO] [stdout]   |
[INFO] [stdout]   = note: `#[derive(Debug)]` triggers a move because taking references to the fields of a packed struct is undefined behaviour
[INFO] [stdout]   = note: this error originates in the derive macro `Debug` (in Nightly builds, run with -Z macro-backtrace for more info)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0507]: cannot move out of `self.adv_data` which is behind a shared reference
[INFO] [stdout]  --> /opt/rustwide/target/debug/build/apache-nimble-sys-31e8b6fd6077532c/out/bindings.rs:3:258500
[INFO] [stdout]   |
[INFO] [stdout] 3 | ...e (Debug)] pub struct ble_hci_le_set_periodic_adv_data_cp { pub adv_handle : u8 , pub operation : u8 , pub adv_data_len : u8 , pub adv_data : __IncompleteArrayField < u8 > , ...
[INFO] [stdout]   |       ----- in this derive macro expansion                                                                                        ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ move occurs because `self.adv_data` has type `__IncompleteArrayField<u8>`, which does not implement the `Copy` trait
[INFO] [stdout]   |
[INFO] [stdout]   = note: `#[derive(Debug)]` triggers a move because taking references to the fields of a packed struct is undefined behaviour
[INFO] [stdout]   = note: this error originates in the derive macro `Debug` (in Nightly builds, run with -Z macro-backtrace for more info)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0507]: cannot move out of `self.scans` which is behind a shared reference
[INFO] [stdout]  --> /opt/rustwide/target/debug/build/apache-nimble-sys-31e8b6fd6077532c/out/bindings.rs:3:262389
[INFO] [stdout]   |
[INFO] [stdout] 3 | ...e (Debug)] pub struct ble_hci_le_set_ext_scan_params_cp { pub own_addr_type : u8 , pub filter_policy : u8 , pub phys : u8 , pub scans : __IncompleteArrayField < scan_params > , ...
[INFO] [stdout]   |       ----- in this derive macro expansion                                                                                     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ move occurs because `self.scans` has type `__IncompleteArrayField<scan_params>`, which does not implement the `Copy` trait
[INFO] [stdout]   |
[INFO] [stdout]   = note: `#[derive(Debug)]` triggers a move because taking references to the fields of a packed struct is undefined behaviour
[INFO] [stdout]   = note: this error originates in the derive macro `Debug` (in Nightly builds, run with -Z macro-backtrace for more info)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0507]: cannot move out of `self.conn_params` which is behind a shared reference
[INFO] [stdout]  --> /opt/rustwide/target/debug/build/apache-nimble-sys-31e8b6fd6077532c/out/bindings.rs:3:268114
[INFO] [stdout]   |
[INFO] [stdout] 3 | ...e (Debug)] pub struct ble_hci_le_ext_create_conn_cp { pub filter_policy : u8 , pub own_addr_type : u8 , pub peer_addr_type : u8 , pub peer_addr : [u8 ; 6usize] , pub init_phy_mask : u8 , pub conn_params : __IncompleteArrayField < conn_params > , ...
[INFO] [stdout]   |       ----- in this derive macro expansion                                                                                                                                                    ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ move occurs because `self.conn_params` has type `__IncompleteArrayField<conn_params>`, which does not implement the `Copy` trait
[INFO] [stdout]   |
[INFO] [stdout]   = note: `#[derive(Debug)]` triggers a move because taking references to the fields of a packed struct is undefined behaviour
[INFO] [stdout]   = note: this error originates in the derive macro `Debug` (in Nightly builds, run with -Z macro-backtrace for more info)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0507]: cannot move out of `self.return_params` which is behind a shared reference
[INFO] [stdout]  --> /opt/rustwide/target/debug/build/apache-nimble-sys-31e8b6fd6077532c/out/bindings.rs:3:299510
[INFO] [stdout]   |
[INFO] [stdout] 3 | ...e (Debug)] pub struct ble_hci_ev_command_complete { pub num_packets : u8 , pub opcode : u16 , pub status : u8 , pub return_params : __IncompleteArrayField < u8 > , ...
[INFO] [stdout]   |       ----- in this derive macro expansion                                                                         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ move occurs because `self.return_params` has type `__IncompleteArrayField<u8>`, which does not implement the `Copy` trait
[INFO] [stdout]   |
[INFO] [stdout]   = note: `#[derive(Debug)]` triggers a move because taking references to the fields of a packed struct is undefined behaviour
[INFO] [stdout]   = note: this error originates in the derive macro `Debug` (in Nightly builds, run with -Z macro-backtrace for more info)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0507]: cannot move out of `self.completed` which is behind a shared reference
[INFO] [stdout]  --> /opt/rustwide/target/debug/build/apache-nimble-sys-31e8b6fd6077532c/out/bindings.rs:3:304882
[INFO] [stdout]   |
[INFO] [stdout] 3 | ...erive (Debug)] pub struct ble_hci_ev_num_comp_pkts { pub count : u8 , pub completed : __IncompleteArrayField < comp_pkt > , } # [test]...
[INFO] [stdout]   |           ----- in this derive macro expansion                           ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ move occurs because `self.completed` has type `__IncompleteArrayField<comp_pkt>`, which does not implement the `Copy` trait
[INFO] [stdout]   |
[INFO] [stdout]   = note: `#[derive(Debug)]` triggers a move because taking references to the fields of a packed struct is undefined behaviour
[INFO] [stdout]   = note: this error originates in the derive macro `Debug` (in Nightly builds, run with -Z macro-backtrace for more info)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0507]: cannot move out of `self.data` which is behind a shared reference
[INFO] [stdout]  --> /opt/rustwide/target/debug/build/apache-nimble-sys-31e8b6fd6077532c/out/bindings.rs:3:307662
[INFO] [stdout]   |
[INFO] [stdout] 3 | ...] # [derive (Debug)] pub struct ble_hci_ev_le_meta { pub subevent : u8 , pub data : __IncompleteArrayField < u8 > , } # [test] fn bind...
[INFO] [stdout]   |                 ----- in this derive macro expansion                        ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ move occurs because `self.data` has type `__IncompleteArrayField<u8>`, which does not implement the `Copy` trait
[INFO] [stdout]   |
[INFO] [stdout]   = note: `#[derive(Debug)]` triggers a move because taking references to the fields of a packed struct is undefined behaviour
[INFO] [stdout]   = note: this error originates in the derive macro `Debug` (in Nightly builds, run with -Z macro-backtrace for more info)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0507]: cannot move out of `self.data` which is behind a shared reference
[INFO] [stdout]  --> /opt/rustwide/target/debug/build/apache-nimble-sys-31e8b6fd6077532c/out/bindings.rs:3:309332
[INFO] [stdout]   |
[INFO] [stdout] 3 | ...] # [derive (Debug)] pub struct ble_hci_ev_vendor_debug { pub id : u8 , pub data : __IncompleteArrayField < u8 > , } # [test] fn bindg...
[INFO] [stdout]   |                 ----- in this derive macro expansion                       ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ move occurs because `self.data` has type `__IncompleteArrayField<u8>`, which does not implement the `Copy` trait
[INFO] [stdout]   |
[INFO] [stdout]   = note: `#[derive(Debug)]` triggers a move because taking references to the fields of a packed struct is undefined behaviour
[INFO] [stdout]   = note: this error originates in the derive macro `Debug` (in Nightly builds, run with -Z macro-backtrace for more info)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0507]: cannot move out of `self.data` which is behind a shared reference
[INFO] [stdout]  --> /opt/rustwide/target/debug/build/apache-nimble-sys-31e8b6fd6077532c/out/bindings.rs:3:313737
[INFO] [stdout]   |
[INFO] [stdout] 3 | ...e (Debug)] pub struct adv_report { pub type_ : u8 , pub addr_type : u8 , pub addr : [u8 ; 6usize] , pub data_len : u8 , pub data : __IncompleteArrayField < u8 > , ...
[INFO] [stdout]   |       ----- in this derive macro expansion                                                                                 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ move occurs because `self.data` has type `__IncompleteArrayField<u8>`, which does not implement the `Copy` trait
[INFO] [stdout]   |
[INFO] [stdout]   = note: `#[derive(Debug)]` triggers a move because taking references to the fields of a packed struct is undefined behaviour
[INFO] [stdout]   = note: this error originates in the derive macro `Debug` (in Nightly builds, run with -Z macro-backtrace for more info)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0507]: cannot move out of `self.reports` which is behind a shared reference
[INFO] [stdout]  --> /opt/rustwide/target/debug/build/apache-nimble-sys-31e8b6fd6077532c/out/bindings.rs:3:315257
[INFO] [stdout]   |
[INFO] [stdout] 3 | ...e (Debug)] pub struct ble_hci_ev_le_subev_adv_rpt { pub subev_code : u8 , pub num_reports : u8 , pub reports : __IncompleteArrayField < adv_report > , ...
[INFO] [stdout]   |       ----- in this derive macro expansion                                                          ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ move occurs because `self.reports` has type `__IncompleteArrayField<adv_report>`, which does not implement the `Copy` trait
[INFO] [stdout]   |
[INFO] [stdout]   = note: `#[derive(Debug)]` triggers a move because taking references to the fields of a packed struct is undefined behaviour
[INFO] [stdout]   = note: this error originates in the derive macro `Debug` (in Nightly builds, run with -Z macro-backtrace for more info)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0507]: cannot move out of `self.reports` which is behind a shared reference
[INFO] [stdout]  --> /opt/rustwide/target/debug/build/apache-nimble-sys-31e8b6fd6077532c/out/bindings.rs:3:335593
[INFO] [stdout]   |
[INFO] [stdout] 3 | ...e (Debug)] pub struct ble_hci_ev_le_subev_direct_adv_rpt { pub subev_code : u8 , pub num_reports : u8 , pub reports : __IncompleteArrayField < dir_adv_report > , ...
[INFO] [stdout]   |       ----- in this derive macro expansion                                                                 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ move occurs because `self.reports` has type `__IncompleteArrayField<dir_adv_report>`, which does not implement the `Copy` trait
[INFO] [stdout]   |
[INFO] [stdout]   = note: `#[derive(Debug)]` triggers a move because taking references to the fields of a packed struct is undefined behaviour
[INFO] [stdout]   = note: this error originates in the derive macro `Debug` (in Nightly builds, run with -Z macro-backtrace for more info)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0507]: cannot move out of `self.data` which is behind a shared reference
[INFO] [stdout]  --> /opt/rustwide/target/debug/build/apache-nimble-sys-31e8b6fd6077532c/out/bindings.rs:3:339208
[INFO] [stdout]   |
[INFO] [stdout] 3 | ...e (Debug)] pub struct ext_adv_report { pub evt_type : u16 , pub addr_type : u8 , pub addr : [u8 ; 6usize] , pub pri_phy : u8 , pub sec_phy : u8 , pub sid : u8 , pub tx_power : i8 , pub rssi : i8 , pub periodic_itvl : u16 , pub dir_addr_type : u8 , pub dir_addr : [u8 ; 6usize] , pub data_len : u8 , pub data : __IncompleteArrayField < u8 > , ...
[INFO] [stdout]   |       ----- in this derive macro expansion                                                                                                                                                                                                                                                                    ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ move occurs because `self.data` has type `__IncompleteArrayField<u8>`, which does not implement the `Copy` trait
[INFO] [stdout]   |
[INFO] [stdout]   = note: `#[derive(Debug)]` triggers a move because taking references to the fields of a packed struct is undefined behaviour
[INFO] [stdout]   = note: this error originates in the derive macro `Debug` (in Nightly builds, run with -Z macro-backtrace for more info)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0507]: cannot move out of `self.reports` which is behind a shared reference
[INFO] [stdout]  --> /opt/rustwide/target/debug/build/apache-nimble-sys-31e8b6fd6077532c/out/bindings.rs:3:342574
[INFO] [stdout]   |
[INFO] [stdout] 3 | ...e (Debug)] pub struct ble_hci_ev_le_subev_ext_adv_rpt { pub subev_code : u8 , pub num_reports : u8 , pub reports : __IncompleteArrayField < ext_adv_report > , ...
[INFO] [stdout]   |       ----- in this derive macro expansion                                                              ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ move occurs because `self.reports` has type `__IncompleteArrayField<ext_adv_report>`, which does not implement the `Copy` trait
[INFO] [stdout]   |
[INFO] [stdout]   = note: `#[derive(Debug)]` triggers a move because taking references to the fields of a packed struct is undefined behaviour
[INFO] [stdout]   = note: this error originates in the derive macro `Debug` (in Nightly builds, run with -Z macro-backtrace for more info)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0507]: cannot move out of `self.data` which is behind a shared reference
[INFO] [stdout]  --> /opt/rustwide/target/debug/build/apache-nimble-sys-31e8b6fd6077532c/out/bindings.rs:3:347327
[INFO] [stdout]   |
[INFO] [stdout] 3 | ...e (Debug)] pub struct ble_hci_ev_le_subev_periodic_adv_rpt { pub subev_code : u8 , pub sync_handle : u16 , pub tx_power : i8 , pub rssi : i8 , pub cte_type : u8 , pub data_status : u8 , pub data_len : u8 , pub data : __IncompleteArrayField < u8 > , ...
[INFO] [stdout]   |       ----- in this derive macro expansion                                                                                                                                                                       ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ move occurs because `self.data` has type `__IncompleteArrayField<u8>`, which does not implement the `Copy` trait
[INFO] [stdout]   |
[INFO] [stdout]   = note: `#[derive(Debug)]` triggers a move because taking references to the fields of a packed struct is undefined behaviour
[INFO] [stdout]   = note: this error originates in the derive macro `Debug` (in Nightly builds, run with -Z macro-backtrace for more info)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0507]: cannot move out of `self.bis` which is behind a shared reference
[INFO] [stdout]  --> /opt/rustwide/target/debug/build/apache-nimble-sys-31e8b6fd6077532c/out/bindings.rs:3:368725
[INFO] [stdout]   |
[INFO] [stdout] 3 | ...e (Debug)] pub struct ble_hci_ev_le_subev_big_complete { pub subev_code : u8 , pub status : u8 , pub big_handle : u8 , pub big_sync_delay : [u8 ; 3usize] , pub transport_latency : [u8 ; 3usize] , pub phy : u8 , pub nse : u8 , pub bn : u8 , pub pto : u8 , pub irc : u8 , pub max_pdu : u16 , pub iso_interval : u16 , pub bis_cnt : u8 , pub bis : __IncompleteArrayField < u16 > , ...
[INFO] [stdout]   |       ----- in this derive macro expansion                                                                                                                                                                                                                                                                                                       ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ move occurs because `self.bis` has type `__IncompleteArrayField<u16>`, which does not implement the `Copy` trait
[INFO] [stdout]   |
[INFO] [stdout]   = note: `#[derive(Debug)]` triggers a move because taking references to the fields of a packed struct is undefined behaviour
[INFO] [stdout]   = note: this error originates in the derive macro `Debug` (in Nightly builds, run with -Z macro-backtrace for more info)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0507]: cannot move out of `self.bis_handles` which is behind a shared reference
[INFO] [stdout]  --> /opt/rustwide/target/debug/build/apache-nimble-sys-31e8b6fd6077532c/out/bindings.rs:3:374560
[INFO] [stdout]   |
[INFO] [stdout] 3 | ...e (Debug)] pub struct ble_hci_ev_le_subev_big_sync_established { pub subev_code : u8 , pub status : u8 , pub big_handle : u8 , pub transport_latency : [u8 ; 3usize] , pub nse : u8 , pub bn : u8 , pub pto : u8 , pub irc : u8 , pub max_pdu : u16 , pub iso_interval : u16 , pub bis_cnt : u8 , pub bis_handles : __IncompleteArrayField < u16 > , ...
[INFO] [stdout]   |       ----- in this derive macro expansion                                                                                                                                                                                                                                                           ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ move occurs because `self.bis_handles` has type `__IncompleteArrayField<u16>`, which does not implement the `Copy` trait
[INFO] [stdout]   |
[INFO] [stdout]   = note: `#[derive(Debug)]` triggers a move because taking references to the fields of a packed struct is undefined behaviour
[INFO] [stdout]   = note: this error originates in the derive macro `Debug` (in Nightly builds, run with -Z macro-backtrace for more info)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: aborting due to 21 previous errors; 6 warnings emitted
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] For more information about this error, try `rustc --explain E0507`.
[INFO] [stdout] 
[INFO] [stderr] The following warnings were emitted during compilation:
[INFO] [stderr] 
[INFO] [stderr] warning: apache-nimble-sys@0.0.1: Compiler version doesn't include clang or GCC: "cc" "--version"
[INFO] [stderr] 
[INFO] [stderr] error: could not compile `apache-nimble-sys` (lib) due to 22 previous errors; 6 warnings emitted
[INFO] [stderr] warning: build failed, waiting for other jobs to finish...
[INFO] [stdout] warning: unused variable: `ptr`
[INFO] [stdout]  --> src/lib.rs:8:17
[INFO] [stdout]   |
[INFO] [stdout] 8 |     pub fn free(ptr: *mut cty::c_void) {}
[INFO] [stdout]   |                 ^^^ help: if this is intentional, prefix it with an underscore: `_ptr`
[INFO] [stdout]   |
[INFO] [stdout]   = note: `#[warn(unused_variables)]` on by default
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: unused variable: `amt`
[INFO] [stdout]   --> src/lib.rs:11:19
[INFO] [stdout]    |
[INFO] [stdout] 11 |     pub fn malloc(amt: cty::size_t) -> *mut cty::c_void {
[INFO] [stdout]    |                   ^^^ help: if this is intentional, prefix it with an underscore: `_amt`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: unused variable: `file`
[INFO] [stdout]   --> src/lib.rs:16:26
[INFO] [stdout]    |
[INFO] [stdout] 16 |     pub fn __assert_func(file: *const char, line: usize, func: *const char, expr: *const char) {
[INFO] [stdout]    |                          ^^^^ help: if this is intentional, prefix it with an underscore: `_file`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: unused variable: `line`
[INFO] [stdout]   --> src/lib.rs:16:45
[INFO] [stdout]    |
[INFO] [stdout] 16 |     pub fn __assert_func(file: *const char, line: usize, func: *const char, expr: *const char) {
[INFO] [stdout]    |                                             ^^^^ help: if this is intentional, prefix it with an underscore: `_line`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: unused variable: `func`
[INFO] [stdout]   --> src/lib.rs:16:58
[INFO] [stdout]    |
[INFO] [stdout] 16 |     pub fn __assert_func(file: *const char, line: usize, func: *const char, expr: *const char) {
[INFO] [stdout]    |                                                          ^^^^ help: if this is intentional, prefix it with an underscore: `_func`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: unused variable: `expr`
[INFO] [stdout]   --> src/lib.rs:16:77
[INFO] [stdout]    |
[INFO] [stdout] 16 |     pub fn __assert_func(file: *const char, line: usize, func: *const char, expr: *const char) {
[INFO] [stdout]    |                                                                             ^^^^ help: if this is intentional, prefix it with an underscore: `_expr`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0507]: cannot move out of `self.data` which is behind a shared reference
[INFO] [stdout]  --> /opt/rustwide/target/debug/build/apache-nimble-sys-31e8b6fd6077532c/out/bindings.rs:3:152615
[INFO] [stdout]   |
[INFO] [stdout] 3 | ...[derive (Debug)] pub struct ble_hci_cmd { pub opcode : u16 , pub length : u8 , pub data : __IncompleteArrayField < u8 > , } # [test] f...
[INFO] [stdout]   |             ----- in this derive macro expansion                                  ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ move occurs because `self.data` has type `__IncompleteArrayField<u8>`, which does not implement the `Copy` trait
[INFO] [stdout]   |
[INFO] [stdout]   = note: `#[derive(Debug)]` triggers a move because taking references to the fields of a packed struct is undefined behaviour
[INFO] [stdout]   = note: this error originates in the derive macro `Debug` (in Nightly builds, run with -Z macro-backtrace for more info)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]  --> /opt/rustwide/target/debug/build/apache-nimble-sys-31e8b6fd6077532c/out/bindings.rs:3:152988
[INFO] [stdout]   |
[INFO] [stdout] 3 | ..._hci_cmd))) ; assert_eq ! (unsafe { & (* (:: core :: ptr :: null :: < ble_hci_cmd > ())) . opcode as * const _ as usize } , 0usize , c...
[INFO] [stdout]   |                                        ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]   |
[INFO] [stdout]   = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]   = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]   = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0507]: cannot move out of `self.data` which is behind a shared reference
[INFO] [stdout]  --> /opt/rustwide/target/debug/build/apache-nimble-sys-31e8b6fd6077532c/out/bindings.rs:3:153698
[INFO] [stdout]   |
[INFO] [stdout] 3 | ...# [derive (Debug)] pub struct ble_hci_ev { pub opcode : u8 , pub length : u8 , pub data : __IncompleteArrayField < u8 > , } # [test] f...
[INFO] [stdout]   |               ----- in this derive macro expansion                                ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ move occurs because `self.data` has type `__IncompleteArrayField<u8>`, which does not implement the `Copy` trait
[INFO] [stdout]   |
[INFO] [stdout]   = note: `#[derive(Debug)]` triggers a move because taking references to the fields of a packed struct is undefined behaviour
[INFO] [stdout]   = note: this error originates in the derive macro `Debug` (in Nightly builds, run with -Z macro-backtrace for more info)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]  --> /opt/rustwide/target/debug/build/apache-nimble-sys-31e8b6fd6077532c/out/bindings.rs:3:155200
[INFO] [stdout]   |
[INFO] [stdout] 3 | ...)) ; assert_eq ! (unsafe { & (* (:: core :: ptr :: null :: < ble_hci_lc_disconnect_cp > ())) . conn_handle as * const _ as usize } , 0...
[INFO] [stdout]   |                               ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]   |
[INFO] [stdout]   = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]   = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]   = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]  --> /opt/rustwide/target/debug/build/apache-nimble-sys-31e8b6fd6077532c/out/bindings.rs:3:156189
[INFO] [stdout]   |
[INFO] [stdout] 3 | ...) ; assert_eq ! (unsafe { & (* (:: core :: ptr :: null :: < ble_hci_rd_rem_ver_info_cp > ())) . conn_handle as * const _ as usize } , ...
[INFO] [stdout]   |                              ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]   |
[INFO] [stdout]   = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]   = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]   = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]  --> /opt/rustwide/target/debug/build/apache-nimble-sys-31e8b6fd6077532c/out/bindings.rs:3:156956
[INFO] [stdout]   |
[INFO] [stdout] 3 | ...) ; assert_eq ! (unsafe { & (* (:: core :: ptr :: null :: < ble_hci_cb_set_event_mask_cp > ())) . event_mask as * const _ as usize } ,...
[INFO] [stdout]   |                              ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]   |
[INFO] [stdout]   = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]   = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]   = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]  --> /opt/rustwide/target/debug/build/apache-nimble-sys-31e8b6fd6077532c/out/bindings.rs:3:157725
[INFO] [stdout]   |
[INFO] [stdout] 3 | ...)) ; assert_eq ! (unsafe { & (* (:: core :: ptr :: null :: < ble_hci_cb_read_tx_pwr_cp > ())) . conn_handle as * const _ as usize } , ...
[INFO] [stdout]   |                               ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]   |
[INFO] [stdout]   = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]   = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]   = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]  --> /opt/rustwide/target/debug/build/apache-nimble-sys-31e8b6fd6077532c/out/bindings.rs:3:158730
[INFO] [stdout]   |
[INFO] [stdout] 3 | ...)) ; assert_eq ! (unsafe { & (* (:: core :: ptr :: null :: < ble_hci_cb_read_tx_pwr_rp > ())) . conn_handle as * const _ as usize } , ...
[INFO] [stdout]   |                               ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]   |
[INFO] [stdout]   = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]   = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]   = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]  --> /opt/rustwide/target/debug/build/apache-nimble-sys-31e8b6fd6077532c/out/bindings.rs:3:160562
[INFO] [stdout]   |
[INFO] [stdout] 3 | ... ; assert_eq ! (unsafe { & (* (:: core :: ptr :: null :: < ble_hci_cb_host_buf_size_cp > ())) . acl_data_len as * const _ as usize } ,...
[INFO] [stdout]   |                             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]   |
[INFO] [stdout]   = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]   = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]   = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]  --> /opt/rustwide/target/debug/build/apache-nimble-sys-31e8b6fd6077532c/out/bindings.rs:3:161072
[INFO] [stdout]   |
[INFO] [stdout] 3 | ...))) ; assert_eq ! (unsafe { & (* (:: core :: ptr :: null :: < ble_hci_cb_host_buf_size_cp > ())) . acl_num as * const _ as usize } , 3...
[INFO] [stdout]   |                                ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]   |
[INFO] [stdout]   = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]   = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]   = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]  --> /opt/rustwide/target/debug/build/apache-nimble-sys-31e8b6fd6077532c/out/bindings.rs:3:161317
[INFO] [stdout]   |
[INFO] [stdout] 3 | ...))) ; assert_eq ! (unsafe { & (* (:: core :: ptr :: null :: < ble_hci_cb_host_buf_size_cp > ())) . sco_num as * const _ as usize } , 5...
[INFO] [stdout]   |                                ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]   |
[INFO] [stdout]   = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]   = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]   = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]  --> /opt/rustwide/target/debug/build/apache-nimble-sys-31e8b6fd6077532c/out/bindings.rs:3:162134
[INFO] [stdout]   |
[INFO] [stdout] 3 | ...; assert_eq ! (unsafe { & (* (:: core :: ptr :: null :: < ble_hci_cb_host_num_comp_pkts_entry > ())) . handle as * const _ as usize } ...
[INFO] [stdout]   |                            ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]   |
[INFO] [stdout]   = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]   = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]   = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]  --> /opt/rustwide/target/debug/build/apache-nimble-sys-31e8b6fd6077532c/out/bindings.rs:3:162393
[INFO] [stdout]   |
[INFO] [stdout] 3 | ... ; assert_eq ! (unsafe { & (* (:: core :: ptr :: null :: < ble_hci_cb_host_num_comp_pkts_entry > ())) . count as * const _ as usize } ...
[INFO] [stdout]   |                             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]   |
[INFO] [stdout]   = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]   = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]   = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0507]: cannot move out of `self.h` which is behind a shared reference
[INFO] [stdout]  --> /opt/rustwide/target/debug/build/apache-nimble-sys-31e8b6fd6077532c/out/bindings.rs:3:162736
[INFO] [stdout]   |
[INFO] [stdout] 3 | ...e (Debug)] pub struct ble_hci_cb_host_num_comp_pkts_cp { pub handles : u8 , pub h : __IncompleteArrayField < ble_hci_cb_host_num_comp_pkts_entry > , ...
[INFO] [stdout]   |       ----- in this derive macro expansion                                     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ move occurs because `self.h` has type `__IncompleteArrayField<ble_hci_cb_host_num_comp_pkts_entry>`, which does not implement the `Copy` trait
[INFO] [stdout]   |
[INFO] [stdout]   = note: `#[derive(Debug)]` triggers a move because taking references to the fields of a packed struct is undefined behaviour
[INFO] [stdout]   = note: this error originates in the derive macro `Debug` (in Nightly builds, run with -Z macro-backtrace for more info)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]  --> /opt/rustwide/target/debug/build/apache-nimble-sys-31e8b6fd6077532c/out/bindings.rs:3:164265
[INFO] [stdout]   |
[INFO] [stdout] 3 | ... ; assert_eq ! (unsafe { & (* (:: core :: ptr :: null :: < ble_hci_cb_set_event_mask2_cp > ())) . event_mask2 as * const _ as usize } ...
[INFO] [stdout]   |                             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]   |
[INFO] [stdout]   = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]   = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]   = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]  --> /opt/rustwide/target/debug/build/apache-nimble-sys-31e8b6fd6077532c/out/bindings.rs:3:165051
[INFO] [stdout]   |
[INFO] [stdout] 3 | ...; assert_eq ! (unsafe { & (* (:: core :: ptr :: null :: < ble_hci_cb_rd_auth_pyld_tmo_cp > ())) . conn_handle as * const _ as usize } ...
[INFO] [stdout]   |                            ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]   |
[INFO] [stdout]   = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]   = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]   = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]  --> /opt/rustwide/target/debug/build/apache-nimble-sys-31e8b6fd6077532c/out/bindings.rs:3:165855
[INFO] [stdout]   |
[INFO] [stdout] 3 | ...; assert_eq ! (unsafe { & (* (:: core :: ptr :: null :: < ble_hci_cb_rd_auth_pyld_tmo_rp > ())) . conn_handle as * const _ as usize } ...
[INFO] [stdout]   |                            ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]   |
[INFO] [stdout]   = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]   = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]   = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]  --> /opt/rustwide/target/debug/build/apache-nimble-sys-31e8b6fd6077532c/out/bindings.rs:3:166114
[INFO] [stdout]   |
[INFO] [stdout] 3 | ...))) ; assert_eq ! (unsafe { & (* (:: core :: ptr :: null :: < ble_hci_cb_rd_auth_pyld_tmo_rp > ())) . tmo as * const _ as usize } , 2u...
[INFO] [stdout]   |                                ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]   |
[INFO] [stdout]   = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]   = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]   = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]  --> /opt/rustwide/target/debug/build/apache-nimble-sys-31e8b6fd6077532c/out/bindings.rs:3:166902
[INFO] [stdout]   |
[INFO] [stdout] 3 | ...; assert_eq ! (unsafe { & (* (:: core :: ptr :: null :: < ble_hci_cb_wr_auth_pyld_tmo_cp > ())) . conn_handle as * const _ as usize } ...
[INFO] [stdout]   |                            ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]   |
[INFO] [stdout]   = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]   = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]   = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]  --> /opt/rustwide/target/debug/build/apache-nimble-sys-31e8b6fd6077532c/out/bindings.rs:3:167161
[INFO] [stdout]   |
[INFO] [stdout] 3 | ...))) ; assert_eq ! (unsafe { & (* (:: core :: ptr :: null :: < ble_hci_cb_wr_auth_pyld_tmo_cp > ())) . tmo as * const _ as usize } , 2u...
[INFO] [stdout]   |                                ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]   |
[INFO] [stdout]   = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]   = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]   = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]  --> /opt/rustwide/target/debug/build/apache-nimble-sys-31e8b6fd6077532c/out/bindings.rs:3:167933
[INFO] [stdout]   |
[INFO] [stdout] 3 | ...; assert_eq ! (unsafe { & (* (:: core :: ptr :: null :: < ble_hci_cb_wr_auth_pyld_tmo_rp > ())) . conn_handle as * const _ as usize } ...
[INFO] [stdout]   |                            ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]   |
[INFO] [stdout]   = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]   = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]   = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]  --> /opt/rustwide/target/debug/build/apache-nimble-sys-31e8b6fd6077532c/out/bindings.rs:3:169022
[INFO] [stdout]   |
[INFO] [stdout] 3 | ...))) ; assert_eq ! (unsafe { & (* (:: core :: ptr :: null :: < ble_hci_ip_rd_local_ver_rp > ())) . hci_rev as * const _ as usize } , 1u...
[INFO] [stdout]   |                                ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]   |
[INFO] [stdout]   = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]   = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]   = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]  --> /opt/rustwide/target/debug/build/apache-nimble-sys-31e8b6fd6077532c/out/bindings.rs:3:169508
[INFO] [stdout]   |
[INFO] [stdout] 3 | ...) ; assert_eq ! (unsafe { & (* (:: core :: ptr :: null :: < ble_hci_ip_rd_local_ver_rp > ())) . manufacturer as * const _ as usize } ,...
[INFO] [stdout]   |                              ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]   |
[INFO] [stdout]   = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]   = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]   = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]  --> /opt/rustwide/target/debug/build/apache-nimble-sys-31e8b6fd6077532c/out/bindings.rs:3:169761
[INFO] [stdout]   |
[INFO] [stdout] 3 | ...)) ; assert_eq ! (unsafe { & (* (:: core :: ptr :: null :: < ble_hci_ip_rd_local_ver_rp > ())) . lmp_subver as * const _ as usize } , ...
[INFO] [stdout]   |                               ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]   |
[INFO] [stdout]   = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]   = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]   = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]  --> /opt/rustwide/target/debug/build/apache-nimble-sys-31e8b6fd6077532c/out/bindings.rs:3:171311
[INFO] [stdout]   |
[INFO] [stdout] 3 | ...) ; assert_eq ! (unsafe { & (* (:: core :: ptr :: null :: < ble_hci_ip_rd_loc_supp_feat_rp > ())) . features as * const _ as usize } ,...
[INFO] [stdout]   |                              ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]   |
[INFO] [stdout]   = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]   = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]   = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]  --> /opt/rustwide/target/debug/build/apache-nimble-sys-31e8b6fd6077532c/out/bindings.rs:3:172128
[INFO] [stdout]   |
[INFO] [stdout] 3 | ...) ; assert_eq ! (unsafe { & (* (:: core :: ptr :: null :: < ble_hci_ip_rd_buf_size_rp > ())) . acl_data_len as * const _ as usize } , ...
[INFO] [stdout]   |                              ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]   |
[INFO] [stdout]   = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]   = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]   = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]  --> /opt/rustwide/target/debug/build/apache-nimble-sys-31e8b6fd6077532c/out/bindings.rs:3:172630
[INFO] [stdout]   |
[INFO] [stdout] 3 | ...n))) ; assert_eq ! (unsafe { & (* (:: core :: ptr :: null :: < ble_hci_ip_rd_buf_size_rp > ())) . acl_num as * const _ as usize } , 3u...
[INFO] [stdout]   |                                 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]   |
[INFO] [stdout]   = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]   = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]   = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]  --> /opt/rustwide/target/debug/build/apache-nimble-sys-31e8b6fd6077532c/out/bindings.rs:3:172871
[INFO] [stdout]   |
[INFO] [stdout] 3 | ...m))) ; assert_eq ! (unsafe { & (* (:: core :: ptr :: null :: < ble_hci_ip_rd_buf_size_rp > ())) . sco_num as * const _ as usize } , 5u...
[INFO] [stdout]   |                                 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]   |
[INFO] [stdout]   = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]   = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]   = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]  --> /opt/rustwide/target/debug/build/apache-nimble-sys-31e8b6fd6077532c/out/bindings.rs:3:174293
[INFO] [stdout]   |
[INFO] [stdout] 3 | ...si_cp))) ; assert_eq ! (unsafe { & (* (:: core :: ptr :: null :: < ble_hci_rd_rssi_cp > ())) . handle as * const _ as usize } , 0usize...
[INFO] [stdout]   |                                     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]   |
[INFO] [stdout]   = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]   = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]   = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]  --> /opt/rustwide/target/debug/build/apache-nimble-sys-31e8b6fd6077532c/out/bindings.rs:3:174986
[INFO] [stdout]   |
[INFO] [stdout] 3 | ...si_rp))) ; assert_eq ! (unsafe { & (* (:: core :: ptr :: null :: < ble_hci_rd_rssi_rp > ())) . handle as * const _ as usize } , 0usize...
[INFO] [stdout]   |                                     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]   |
[INFO] [stdout]   = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]   = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]   = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]  --> /opt/rustwide/target/debug/build/apache-nimble-sys-31e8b6fd6077532c/out/bindings.rs:3:175948
[INFO] [stdout]   |
[INFO] [stdout] 3 | ...) ; assert_eq ! (unsafe { & (* (:: core :: ptr :: null :: < ble_hci_le_set_event_mask_cp > ())) . event_mask as * const _ as usize } ,...
[INFO] [stdout]   |                              ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]   |
[INFO] [stdout]   = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]   = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]   = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]  --> /opt/rustwide/target/debug/build/apache-nimble-sys-31e8b6fd6077532c/out/bindings.rs:3:176721
[INFO] [stdout]   |
[INFO] [stdout] 3 | ...))) ; assert_eq ! (unsafe { & (* (:: core :: ptr :: null :: < ble_hci_le_rd_buf_size_rp > ())) . data_len as * const _ as usize } , 0u...
[INFO] [stdout]   |                                ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]   |
[INFO] [stdout]   = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]   = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]   = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]  --> /opt/rustwide/target/debug/build/apache-nimble-sys-31e8b6fd6077532c/out/bindings.rs:3:177806
[INFO] [stdout]   |
[INFO] [stdout] 3 | ...)) ; assert_eq ! (unsafe { & (* (:: core :: ptr :: null :: < ble_hci_le_rd_buf_size_v2_rp > ())) . data_len as * const _ as usize } , ...
[INFO] [stdout]   |                               ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]   |
[INFO] [stdout]   = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]   = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]   = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]  --> /opt/rustwide/target/debug/build/apache-nimble-sys-31e8b6fd6077532c/out/bindings.rs:3:178312
[INFO] [stdout]   |
[INFO] [stdout] 3 | ... ; assert_eq ! (unsafe { & (* (:: core :: ptr :: null :: < ble_hci_le_rd_buf_size_v2_rp > ())) . iso_data_len as * const _ as usize } ...
[INFO] [stdout]   |                             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]   |
[INFO] [stdout]   = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]   = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]   = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]  --> /opt/rustwide/target/debug/build/apache-nimble-sys-31e8b6fd6077532c/out/bindings.rs:3:179360
[INFO] [stdout]   |
[INFO] [stdout] 3 | ...) ; assert_eq ! (unsafe { & (* (:: core :: ptr :: null :: < ble_hci_le_rd_loc_supp_feat_rp > ())) . features as * const _ as usize } ,...
[INFO] [stdout]   |                              ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]   |
[INFO] [stdout]   = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]   = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]   = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]  --> /opt/rustwide/target/debug/build/apache-nimble-sys-31e8b6fd6077532c/out/bindings.rs:3:181055
[INFO] [stdout]   |
[INFO] [stdout] 3 | ... ; assert_eq ! (unsafe { & (* (:: core :: ptr :: null :: < ble_hci_le_set_adv_params_cp > ())) . min_interval as * const _ as usize } ...
[INFO] [stdout]   |                             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]   |
[INFO] [stdout]   = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]   = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]   = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]  --> /opt/rustwide/target/debug/build/apache-nimble-sys-31e8b6fd6077532c/out/bindings.rs:3:181312
[INFO] [stdout]   |
[INFO] [stdout] 3 | ... ; assert_eq ! (unsafe { & (* (:: core :: ptr :: null :: < ble_hci_le_set_adv_params_cp > ())) . max_interval as * const _ as usize } ...
[INFO] [stdout]   |                             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]   |
[INFO] [stdout]   = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]   = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]   = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]  --> /opt/rustwide/target/debug/build/apache-nimble-sys-31e8b6fd6077532c/out/bindings.rs:3:187635
[INFO] [stdout]   |
[INFO] [stdout] 3 | ...) ; assert_eq ! (unsafe { & (* (:: core :: ptr :: null :: < ble_hci_le_set_scan_params_cp > ())) . scan_itvl as * const _ as usize } ,...
[INFO] [stdout]   |                              ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]   |
[INFO] [stdout]   = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]   = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]   = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]  --> /opt/rustwide/target/debug/build/apache-nimble-sys-31e8b6fd6077532c/out/bindings.rs:3:187888
[INFO] [stdout]   |
[INFO] [stdout] 3 | ... ; assert_eq ! (unsafe { & (* (:: core :: ptr :: null :: < ble_hci_le_set_scan_params_cp > ())) . scan_window as * const _ as usize } ...
[INFO] [stdout]   |                             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]   |
[INFO] [stdout]   = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]   = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]   = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]  --> /opt/rustwide/target/debug/build/apache-nimble-sys-31e8b6fd6077532c/out/bindings.rs:3:190490
[INFO] [stdout]   |
[INFO] [stdout] 3 | ...))) ; assert_eq ! (unsafe { & (* (:: core :: ptr :: null :: < ble_hci_le_create_conn_cp > ())) . scan_itvl as * const _ as usize } , 0...
[INFO] [stdout]   |                                ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]   |
[INFO] [stdout]   = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]   = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]   = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]  --> /opt/rustwide/target/debug/build/apache-nimble-sys-31e8b6fd6077532c/out/bindings.rs:3:190735
[INFO] [stdout]   |
[INFO] [stdout] 3 | ...)) ; assert_eq ! (unsafe { & (* (:: core :: ptr :: null :: < ble_hci_le_create_conn_cp > ())) . scan_window as * const _ as usize } , ...
[INFO] [stdout]   |                               ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]   |
[INFO] [stdout]   = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]   = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]   = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]  --> /opt/rustwide/target/debug/build/apache-nimble-sys-31e8b6fd6077532c/out/bindings.rs:3:191991
[INFO] [stdout]   |
[INFO] [stdout] 3 | ...) ; assert_eq ! (unsafe { & (* (:: core :: ptr :: null :: < ble_hci_le_create_conn_cp > ())) . min_conn_itvl as * const _ as usize } ,...
[INFO] [stdout]   |                              ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]   |
[INFO] [stdout]   = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]   = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]   = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]  --> /opt/rustwide/target/debug/build/apache-nimble-sys-31e8b6fd6077532c/out/bindings.rs:3:192245
[INFO] [stdout]   |
[INFO] [stdout] 3 | ...) ; assert_eq ! (unsafe { & (* (:: core :: ptr :: null :: < ble_hci_le_create_conn_cp > ())) . max_conn_itvl as * const _ as usize } ,...
[INFO] [stdout]   |                              ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]   |
[INFO] [stdout]   = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]   = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]   = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]  --> /opt/rustwide/target/debug/build/apache-nimble-sys-31e8b6fd6077532c/out/bindings.rs:3:192499
[INFO] [stdout]   |
[INFO] [stdout] 3 | ...) ; assert_eq ! (unsafe { & (* (:: core :: ptr :: null :: < ble_hci_le_create_conn_cp > ())) . conn_latency as * const _ as usize } , ...
[INFO] [stdout]   |                              ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]   |
[INFO] [stdout]   = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]   = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]   = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]  --> /opt/rustwide/target/debug/build/apache-nimble-sys-31e8b6fd6077532c/out/bindings.rs:3:192751
[INFO] [stdout]   |
[INFO] [stdout] 3 | ...ncy))) ; assert_eq ! (unsafe { & (* (:: core :: ptr :: null :: < ble_hci_le_create_conn_cp > ())) . tmo as * const _ as usize } , 19us...
[INFO] [stdout]   |                                   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]   |
[INFO] [stdout]   = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]   = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]   = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]  --> /opt/rustwide/target/debug/build/apache-nimble-sys-31e8b6fd6077532c/out/bindings.rs:3:192985
[INFO] [stdout]   |
[INFO] [stdout] 3 | ...o))) ; assert_eq ! (unsafe { & (* (:: core :: ptr :: null :: < ble_hci_le_create_conn_cp > ())) . min_ce as * const _ as usize } , 21u...
[INFO] [stdout]   |                                 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]   |
[INFO] [stdout]   = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]   = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]   = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]  --> /opt/rustwide/target/debug/build/apache-nimble-sys-31e8b6fd6077532c/out/bindings.rs:3:193225
[INFO] [stdout]   |
[INFO] [stdout] 3 | ...e))) ; assert_eq ! (unsafe { & (* (:: core :: ptr :: null :: < ble_hci_le_create_conn_cp > ())) . max_ce as * const _ as usize } , 23u...
[INFO] [stdout]   |                                 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]   |
[INFO] [stdout]   = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]   = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]   = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]  --> /opt/rustwide/target/debug/build/apache-nimble-sys-31e8b6fd6077532c/out/bindings.rs:3:196918
[INFO] [stdout]   |
[INFO] [stdout] 3 | ...)) ; assert_eq ! (unsafe { & (* (:: core :: ptr :: null :: < ble_hci_le_conn_update_cp > ())) . conn_handle as * const _ as usize } , ...
[INFO] [stdout]   |                               ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]   |
[INFO] [stdout]   = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]   = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]   = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]  --> /opt/rustwide/target/debug/build/apache-nimble-sys-31e8b6fd6077532c/out/bindings.rs:3:197167
[INFO] [stdout]   |
[INFO] [stdout] 3 | ...) ; assert_eq ! (unsafe { & (* (:: core :: ptr :: null :: < ble_hci_le_conn_update_cp > ())) . conn_itvl_min as * const _ as usize } ,...
[INFO] [stdout]   |                              ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]   |
[INFO] [stdout]   = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]   = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]   = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]  --> /opt/rustwide/target/debug/build/apache-nimble-sys-31e8b6fd6077532c/out/bindings.rs:3:197420
[INFO] [stdout]   |
[INFO] [stdout] 3 | ...) ; assert_eq ! (unsafe { & (* (:: core :: ptr :: null :: < ble_hci_le_conn_update_cp > ())) . conn_itvl_max as * const _ as usize } ,...
[INFO] [stdout]   |                              ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]   |
[INFO] [stdout]   = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]   = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]   = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]  --> /opt/rustwide/target/debug/build/apache-nimble-sys-31e8b6fd6077532c/out/bindings.rs:3:197673
[INFO] [stdout]   |
[INFO] [stdout] 3 | ...) ; assert_eq ! (unsafe { & (* (:: core :: ptr :: null :: < ble_hci_le_conn_update_cp > ())) . conn_latency as * const _ as usize } , ...
[INFO] [stdout]   |                              ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]   |
[INFO] [stdout]   = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]   = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]   = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]  --> /opt/rustwide/target/debug/build/apache-nimble-sys-31e8b6fd6077532c/out/bindings.rs:3:197924
[INFO] [stdout]   |
[INFO] [stdout] 3 | ... assert_eq ! (unsafe { & (* (:: core :: ptr :: null :: < ble_hci_le_conn_update_cp > ())) . supervision_timeout as * const _ as usize ...
[INFO] [stdout]   |                           ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]   |
[INFO] [stdout]   = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]   = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]   = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]  --> /opt/rustwide/target/debug/build/apache-nimble-sys-31e8b6fd6077532c/out/bindings.rs:3:198189
[INFO] [stdout]   |
[INFO] [stdout] 3 | ...)) ; assert_eq ! (unsafe { & (* (:: core :: ptr :: null :: < ble_hci_le_conn_update_cp > ())) . min_ce_len as * const _ as usize } , 1...
[INFO] [stdout]   |                               ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]   |
[INFO] [stdout]   = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]   = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]   = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]  --> /opt/rustwide/target/debug/build/apache-nimble-sys-31e8b6fd6077532c/out/bindings.rs:3:198437
[INFO] [stdout]   |
[INFO] [stdout] 3 | ...)) ; assert_eq ! (unsafe { & (* (:: core :: ptr :: null :: < ble_hci_le_conn_update_cp > ())) . max_ce_len as * const _ as usize } , 1...
[INFO] [stdout]   |                               ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]   |
[INFO] [stdout]   = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]   = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]   = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]  --> /opt/rustwide/target/debug/build/apache-nimble-sys-31e8b6fd6077532c/out/bindings.rs:3:199997
[INFO] [stdout]   |
[INFO] [stdout] 3 | ...)) ; assert_eq ! (unsafe { & (* (:: core :: ptr :: null :: < ble_hci_le_rd_chan_map_cp > ())) . conn_handle as * const _ as usize } , ...
[INFO] [stdout]   |                               ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]   |
[INFO] [stdout]   = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]   = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]   = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]  --> /opt/rustwide/target/debug/build/apache-nimble-sys-31e8b6fd6077532c/out/bindings.rs:3:200776
[INFO] [stdout]   |
[INFO] [stdout] 3 | ...)) ; assert_eq ! (unsafe { & (* (:: core :: ptr :: null :: < ble_hci_le_rd_chan_map_rp > ())) . conn_handle as * const _ as usize } , ...
[INFO] [stdout]   |                               ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]   |
[INFO] [stdout]   = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]   = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]   = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]  --> /opt/rustwide/target/debug/build/apache-nimble-sys-31e8b6fd6077532c/out/bindings.rs:3:201767
[INFO] [stdout]   |
[INFO] [stdout] 3 | ...)) ; assert_eq ! (unsafe { & (* (:: core :: ptr :: null :: < ble_hci_le_rd_rem_feat_cp > ())) . conn_handle as * const _ as usize } , ...
[INFO] [stdout]   |                               ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]   |
[INFO] [stdout]   = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]   = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]   = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]  --> /opt/rustwide/target/debug/build/apache-nimble-sys-31e8b6fd6077532c/out/bindings.rs:3:204142
[INFO] [stdout]   |
[INFO] [stdout] 3 | ...p))) ; assert_eq ! (unsafe { & (* (:: core :: ptr :: null :: < ble_hci_le_rand_rp > ())) . random_number as * const _ as usize } , 0us...
[INFO] [stdout]   |                                 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]   |
[INFO] [stdout]   = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]   = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]   = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]  --> /opt/rustwide/target/debug/build/apache-nimble-sys-31e8b6fd6077532c/out/bindings.rs:3:204953
[INFO] [stdout]   |
[INFO] [stdout] 3 | ...) ; assert_eq ! (unsafe { & (* (:: core :: ptr :: null :: < ble_hci_le_start_encrypt_cp > ())) . conn_handle as * const _ as usize } ,...
[INFO] [stdout]   |                              ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]   |
[INFO] [stdout]   = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]   = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]   = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]  --> /opt/rustwide/target/debug/build/apache-nimble-sys-31e8b6fd6077532c/out/bindings.rs:3:205206
[INFO] [stdout]   |
[INFO] [stdout] 3 | ...e))) ; assert_eq ! (unsafe { & (* (:: core :: ptr :: null :: < ble_hci_le_start_encrypt_cp > ())) . rand as * const _ as usize } , 2us...
[INFO] [stdout]   |                                 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]   |
[INFO] [stdout]   = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]   = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]   = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]  --> /opt/rustwide/target/debug/build/apache-nimble-sys-31e8b6fd6077532c/out/bindings.rs:3:205445
[INFO] [stdout]   |
[INFO] [stdout] 3 | ...nd))) ; assert_eq ! (unsafe { & (* (:: core :: ptr :: null :: < ble_hci_le_start_encrypt_cp > ())) . div as * const _ as usize } , 10u...
[INFO] [stdout]   |                                  ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]   |
[INFO] [stdout]   = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]   = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]   = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]  --> /opt/rustwide/target/debug/build/apache-nimble-sys-31e8b6fd6077532c/out/bindings.rs:3:206478
[INFO] [stdout]   |
[INFO] [stdout] 3 | ...; assert_eq ! (unsafe { & (* (:: core :: ptr :: null :: < ble_hci_le_lt_key_req_reply_cp > ())) . conn_handle as * const _ as usize } ...
[INFO] [stdout]   |                            ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]   |
[INFO] [stdout]   = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]   = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]   = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]  --> /opt/rustwide/target/debug/build/apache-nimble-sys-31e8b6fd6077532c/out/bindings.rs:3:207509
[INFO] [stdout]   |
[INFO] [stdout] 3 | ...; assert_eq ! (unsafe { & (* (:: core :: ptr :: null :: < ble_hci_le_lt_key_req_reply_rp > ())) . conn_handle as * const _ as usize } ...
[INFO] [stdout]   |                            ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]   |
[INFO] [stdout]   = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]   = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]   = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]  --> /opt/rustwide/target/debug/build/apache-nimble-sys-31e8b6fd6077532c/out/bindings.rs:3:208321
[INFO] [stdout]   |
[INFO] [stdout] 3 | ...assert_eq ! (unsafe { & (* (:: core :: ptr :: null :: < ble_hci_le_lt_key_req_neg_reply_cp > ())) . conn_handle as * const _ as usize ...
[INFO] [stdout]   |                          ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]   |
[INFO] [stdout]   = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]   = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]   = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]  --> /opt/rustwide/target/debug/build/apache-nimble-sys-31e8b6fd6077532c/out/bindings.rs:3:209141
[INFO] [stdout]   |
[INFO] [stdout] 3 | ...assert_eq ! (unsafe { & (* (:: core :: ptr :: null :: < ble_hci_le_lt_key_req_neg_reply_rp > ())) . conn_handle as * const _ as usize ...
[INFO] [stdout]   |                          ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]   |
[INFO] [stdout]   = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]   = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]   = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]  --> /opt/rustwide/target/debug/build/apache-nimble-sys-31e8b6fd6077532c/out/bindings.rs:3:209920
[INFO] [stdout]   |
[INFO] [stdout] 3 | ...))) ; assert_eq ! (unsafe { & (* (:: core :: ptr :: null :: < ble_hci_le_rd_supp_states_rp > ())) . states as * const _ as usize } , 0...
[INFO] [stdout]   |                                ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]   |
[INFO] [stdout]   = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]   = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]   = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]  --> /opt/rustwide/target/debug/build/apache-nimble-sys-31e8b6fd6077532c/out/bindings.rs:3:212574
[INFO] [stdout]   |
[INFO] [stdout] 3 | ...))) ; assert_eq ! (unsafe { & (* (:: core :: ptr :: null :: < ble_hci_le_test_end_rp > ())) . num_packets as * const _ as usize } , 0u...
[INFO] [stdout]   |                                ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]   |
[INFO] [stdout]   = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]   = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]   = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]  --> /opt/rustwide/target/debug/build/apache-nimble-sys-31e8b6fd6077532c/out/bindings.rs:3:213500
[INFO] [stdout]   |
[INFO] [stdout] 3 | ...; assert_eq ! (unsafe { & (* (:: core :: ptr :: null :: < ble_hci_le_rem_conn_param_rr_cp > ())) . conn_handle as * const _ as usize }...
[INFO] [stdout]   |                            ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]   |
[INFO] [stdout]   = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]   = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]   = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]  --> /opt/rustwide/target/debug/build/apache-nimble-sys-31e8b6fd6077532c/out/bindings.rs:3:213761
[INFO] [stdout]   |
[INFO] [stdout] 3 | ... assert_eq ! (unsafe { & (* (:: core :: ptr :: null :: < ble_hci_le_rem_conn_param_rr_cp > ())) . conn_itvl_min as * const _ as usize ...
[INFO] [stdout]   |                           ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]   |
[INFO] [stdout]   = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]   = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]   = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]  --> /opt/rustwide/target/debug/build/apache-nimble-sys-31e8b6fd6077532c/out/bindings.rs:3:214026
[INFO] [stdout]   |
[INFO] [stdout] 3 | ... assert_eq ! (unsafe { & (* (:: core :: ptr :: null :: < ble_hci_le_rem_conn_param_rr_cp > ())) . conn_itvl_max as * const _ as usize ...
[INFO] [stdout]   |                           ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]   |
[INFO] [stdout]   = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]   = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]   = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]  --> /opt/rustwide/target/debug/build/apache-nimble-sys-31e8b6fd6077532c/out/bindings.rs:3:214291
[INFO] [stdout]   |
[INFO] [stdout] 3 | ... assert_eq ! (unsafe { & (* (:: core :: ptr :: null :: < ble_hci_le_rem_conn_param_rr_cp > ())) . conn_latency as * const _ as usize }...
[INFO] [stdout]   |                           ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]   |
[INFO] [stdout]   = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]   = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]   = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]  --> /opt/rustwide/target/debug/build/apache-nimble-sys-31e8b6fd6077532c/out/bindings.rs:3:214554
[INFO] [stdout]   |
[INFO] [stdout] 3 | ...sert_eq ! (unsafe { & (* (:: core :: ptr :: null :: < ble_hci_le_rem_conn_param_rr_cp > ())) . supervision_timeout as * const _ as usi...
[INFO] [stdout]   |                        ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]   |
[INFO] [stdout]   = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]   = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]   = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]  --> /opt/rustwide/target/debug/build/apache-nimble-sys-31e8b6fd6077532c/out/bindings.rs:3:214831
[INFO] [stdout]   |
[INFO] [stdout] 3 | ...) ; assert_eq ! (unsafe { & (* (:: core :: ptr :: null :: < ble_hci_le_rem_conn_param_rr_cp > ())) . min_ce as * const _ as usize } , ...
[INFO] [stdout]   |                              ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]   |
[INFO] [stdout]   = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]   = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]   = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]  --> /opt/rustwide/target/debug/build/apache-nimble-sys-31e8b6fd6077532c/out/bindings.rs:3:215083
[INFO] [stdout]   |
[INFO] [stdout] 3 | ...) ; assert_eq ! (unsafe { & (* (:: core :: ptr :: null :: < ble_hci_le_rem_conn_param_rr_cp > ())) . max_ce as * const _ as usize } , ...
[INFO] [stdout]   |                              ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]   |
[INFO] [stdout]   = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]   = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]   = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]  --> /opt/rustwide/target/debug/build/apache-nimble-sys-31e8b6fd6077532c/out/bindings.rs:3:215870
[INFO] [stdout]   |
[INFO] [stdout] 3 | ...; assert_eq ! (unsafe { & (* (:: core :: ptr :: null :: < ble_hci_le_rem_conn_param_rr_rp > ())) . conn_handle as * const _ as usize }...
[INFO] [stdout]   |                            ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]   |
[INFO] [stdout]   = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]   = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]   = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]  --> /opt/rustwide/target/debug/build/apache-nimble-sys-31e8b6fd6077532c/out/bindings.rs:3:216696
[INFO] [stdout]   |
[INFO] [stdout] 3 | ... assert_eq ! (unsafe { & (* (:: core :: ptr :: null :: < ble_hci_le_rem_conn_params_nrr_cp > ())) . conn_handle as * const _ as usize ...
[INFO] [stdout]   |                           ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]   |
[INFO] [stdout]   = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]   = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]   = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]  --> /opt/rustwide/target/debug/build/apache-nimble-sys-31e8b6fd6077532c/out/bindings.rs:3:217763
[INFO] [stdout]   |
[INFO] [stdout] 3 | ... assert_eq ! (unsafe { & (* (:: core :: ptr :: null :: < ble_hci_le_rem_conn_params_nrr_rp > ())) . conn_handle as * const _ as usize ...
[INFO] [stdout]   |                           ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]   |
[INFO] [stdout]   = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]   = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]   = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]  --> /opt/rustwide/target/debug/build/apache-nimble-sys-31e8b6fd6077532c/out/bindings.rs:3:218575
[INFO] [stdout]   |
[INFO] [stdout] 3 | ...) ; assert_eq ! (unsafe { & (* (:: core :: ptr :: null :: < ble_hci_le_set_data_len_cp > ())) . conn_handle as * const _ as usize } , ...
[INFO] [stdout]   |                              ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]   |
[INFO] [stdout]   = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]   = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]   = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]  --> /opt/rustwide/target/debug/build/apache-nimble-sys-31e8b6fd6077532c/out/bindings.rs:3:218826
[INFO] [stdout]   |
[INFO] [stdout] 3 | ...)) ; assert_eq ! (unsafe { & (* (:: core :: ptr :: null :: < ble_hci_le_set_data_len_cp > ())) . tx_octets as * const _ as usize } , 2...
[INFO] [stdout]   |                               ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]   |
[INFO] [stdout]   = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]   = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]   = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]  --> /opt/rustwide/target/debug/build/apache-nimble-sys-31e8b6fd6077532c/out/bindings.rs:3:219073
[INFO] [stdout]   |
[INFO] [stdout] 3 | ...))) ; assert_eq ! (unsafe { & (* (:: core :: ptr :: null :: < ble_hci_le_set_data_len_cp > ())) . tx_time as * const _ as usize } , 4u...
[INFO] [stdout]   |                                ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]   |
[INFO] [stdout]   = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]   = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]   = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]  --> /opt/rustwide/target/debug/build/apache-nimble-sys-31e8b6fd6077532c/out/bindings.rs:3:219821
[INFO] [stdout]   |
[INFO] [stdout] 3 | ...) ; assert_eq ! (unsafe { & (* (:: core :: ptr :: null :: < ble_hci_le_set_data_len_rp > ())) . conn_handle as * const _ as usize } , ...
[INFO] [stdout]   |                              ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]   |
[INFO] [stdout]   = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]   = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]   = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]  --> /opt/rustwide/target/debug/build/apache-nimble-sys-31e8b6fd6077532c/out/bindings.rs:3:220651
[INFO] [stdout]   |
[INFO] [stdout] 3 | ...ssert_eq ! (unsafe { & (* (:: core :: ptr :: null :: < ble_hci_le_rd_sugg_def_data_len_rp > ())) . max_tx_octets as * const _ as usize...
[INFO] [stdout]   |                         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]   |
[INFO] [stdout]   = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]   = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]   = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]  --> /opt/rustwide/target/debug/build/apache-nimble-sys-31e8b6fd6077532c/out/bindings.rs:3:220922
[INFO] [stdout]   |
[INFO] [stdout] 3 | ...assert_eq ! (unsafe { & (* (:: core :: ptr :: null :: < ble_hci_le_rd_sugg_def_data_len_rp > ())) . max_tx_time as * const _ as usize ...
[INFO] [stdout]   |                          ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]   |
[INFO] [stdout]   = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]   = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]   = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]  --> /opt/rustwide/target/debug/build/apache-nimble-sys-31e8b6fd6077532c/out/bindings.rs:3:221768
[INFO] [stdout]   |
[INFO] [stdout] 3 | ...ssert_eq ! (unsafe { & (* (:: core :: ptr :: null :: < ble_hci_le_wr_sugg_def_data_len_cp > ())) . max_tx_octets as * const _ as usize...
[INFO] [stdout]   |                         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]   |
[INFO] [stdout]   = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]   = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]   = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]  --> /opt/rustwide/target/debug/build/apache-nimble-sys-31e8b6fd6077532c/out/bindings.rs:3:222039
[INFO] [stdout]   |
[INFO] [stdout] 3 | ...assert_eq ! (unsafe { & (* (:: core :: ptr :: null :: < ble_hci_le_wr_sugg_def_data_len_cp > ())) . max_tx_time as * const _ as usize ...
[INFO] [stdout]   |                          ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]   |
[INFO] [stdout]   = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]   = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]   = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]  --> /opt/rustwide/target/debug/build/apache-nimble-sys-31e8b6fd6077532c/out/bindings.rs:3:231677
[INFO] [stdout]   |
[INFO] [stdout] 3 | ...)) ; assert_eq ! (unsafe { & (* (:: core :: ptr :: null :: < ble_hci_le_set_rpa_tmo_cp > ())) . rpa_timeout as * const _ as usize } , ...
[INFO] [stdout]   |                               ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]   |
[INFO] [stdout]   = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]   = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]   = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]  --> /opt/rustwide/target/debug/build/apache-nimble-sys-31e8b6fd6077532c/out/bindings.rs:3:232527
[INFO] [stdout]   |
[INFO] [stdout] 3 | ... assert_eq ! (unsafe { & (* (:: core :: ptr :: null :: < ble_hci_le_rd_max_data_len_rp > ())) . max_tx_octests as * const _ as usize }...
[INFO] [stdout]   |                           ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]   |
[INFO] [stdout]   = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]   = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]   = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]  --> /opt/rustwide/target/debug/build/apache-nimble-sys-31e8b6fd6077532c/out/bindings.rs:3:232790
[INFO] [stdout]   |
[INFO] [stdout] 3 | ... ; assert_eq ! (unsafe { & (* (:: core :: ptr :: null :: < ble_hci_le_rd_max_data_len_rp > ())) . max_tx_time as * const _ as usize } ...
[INFO] [stdout]   |                             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]   |
[INFO] [stdout]   = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]   = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]   = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]  --> /opt/rustwide/target/debug/build/apache-nimble-sys-31e8b6fd6077532c/out/bindings.rs:3:233047
[INFO] [stdout]   |
[INFO] [stdout] 3 | ... assert_eq ! (unsafe { & (* (:: core :: ptr :: null :: < ble_hci_le_rd_max_data_len_rp > ())) . max_rx_octests as * const _ as usize }...
[INFO] [stdout]   |                           ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]   |
[INFO] [stdout]   = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]   = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]   = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]  --> /opt/rustwide/target/debug/build/apache-nimble-sys-31e8b6fd6077532c/out/bindings.rs:3:233310
[INFO] [stdout]   |
[INFO] [stdout] 3 | ... ; assert_eq ! (unsafe { & (* (:: core :: ptr :: null :: < ble_hci_le_rd_max_data_len_rp > ())) . max_rx_time as * const _ as usize } ...
[INFO] [stdout]   |                             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]   |
[INFO] [stdout]   = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]   = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]   = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]  --> /opt/rustwide/target/debug/build/apache-nimble-sys-31e8b6fd6077532c/out/bindings.rs:3:234036
[INFO] [stdout]   |
[INFO] [stdout] 3 | ...p))) ; assert_eq ! (unsafe { & (* (:: core :: ptr :: null :: < ble_hci_le_rd_phy_cp > ())) . conn_handle as * const _ as usize } , 0us...
[INFO] [stdout]   |                                 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]   |
[INFO] [stdout]   = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]   = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]   = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]  --> /opt/rustwide/target/debug/build/apache-nimble-sys-31e8b6fd6077532c/out/bindings.rs:3:234780
[INFO] [stdout]   |
[INFO] [stdout] 3 | ...p))) ; assert_eq ! (unsafe { & (* (:: core :: ptr :: null :: < ble_hci_le_rd_phy_rp > ())) . conn_handle as * const _ as usize } , 0us...
[INFO] [stdout]   |                                 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]   |
[INFO] [stdout]   = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]   = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]   = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]  --> /opt/rustwide/target/debug/build/apache-nimble-sys-31e8b6fd6077532c/out/bindings.rs:3:237340
[INFO] [stdout]   |
[INFO] [stdout] 3 | ...p))) ; assert_eq ! (unsafe { & (* (:: core :: ptr :: null :: < ble_hci_le_set_phy_cp > ())) . conn_handle as * const _ as usize } , 0u...
[INFO] [stdout]   |                                 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]   |
[INFO] [stdout]   = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]   = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]   = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]  --> /opt/rustwide/target/debug/build/apache-nimble-sys-31e8b6fd6077532c/out/bindings.rs:3:238282
[INFO] [stdout]   |
[INFO] [stdout] 3 | ...s))) ; assert_eq ! (unsafe { & (* (:: core :: ptr :: null :: < ble_hci_le_set_phy_cp > ())) . phy_options as * const _ as usize } , 5u...
[INFO] [stdout]   |                                 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]   |
[INFO] [stdout]   = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]   = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]   = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]  --> /opt/rustwide/target/debug/build/apache-nimble-sys-31e8b6fd6077532c/out/bindings.rs:3:243495
[INFO] [stdout]   |
[INFO] [stdout] 3 | ...) ; assert_eq ! (unsafe { & (* (:: core :: ptr :: null :: < ble_hci_le_set_ext_adv_params_cp > ())) . props as * const _ as usize } , ...
[INFO] [stdout]   |                              ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]   |
[INFO] [stdout]   = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]   = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]   = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0507]: cannot move out of `self.adv_data` which is behind a shared reference
[INFO] [stdout]  --> /opt/rustwide/target/debug/build/apache-nimble-sys-31e8b6fd6077532c/out/bindings.rs:3:248112
[INFO] [stdout]   |
[INFO] [stdout] 3 | ...e (Debug)] pub struct ble_hci_le_set_ext_adv_data_cp { pub adv_handle : u8 , pub operation : u8 , pub fragment_pref : u8 , pub adv_data_len : u8 , pub adv_data : __IncompleteArrayField < u8 > , ...
[INFO] [stdout]   |       ----- in this derive macro expansion                                                                                                            ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ move occurs because `self.adv_data` has type `__IncompleteArrayField<u8>`, which does not implement the `Copy` trait
[INFO] [stdout]   |
[INFO] [stdout]   = note: `#[derive(Debug)]` triggers a move because taking references to the fields of a packed struct is undefined behaviour
[INFO] [stdout]   = note: this error originates in the derive macro `Debug` (in Nightly builds, run with -Z macro-backtrace for more info)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0507]: cannot move out of `self.scan_rsp` which is behind a shared reference
[INFO] [stdout]  --> /opt/rustwide/target/debug/build/apache-nimble-sys-31e8b6fd6077532c/out/bindings.rs:3:250035
[INFO] [stdout]   |
[INFO] [stdout] 3 | ...e (Debug)] pub struct ble_hci_le_set_ext_scan_rsp_data_cp { pub adv_handle : u8 , pub operation : u8 , pub fragment_pref : u8 , pub scan_rsp_len : u8 , pub scan_rsp : __IncompleteArrayField < u8 > , ...
[INFO] [stdout]   |       ----- in this derive macro expansion                                                                                                                 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ move occurs because `self.scan_rsp` has type `__IncompleteArrayField<u8>`, which does not implement the `Copy` trait
[INFO] [stdout]   |
[INFO] [stdout]   = note: `#[derive(Debug)]` triggers a move because taking references to the fields of a packed struct is undefined behaviour
[INFO] [stdout]   = note: this error originates in the derive macro `Debug` (in Nightly builds, run with -Z macro-backtrace for more info)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]  --> /opt/rustwide/target/debug/build/apache-nimble-sys-31e8b6fd6077532c/out/bindings.rs:3:252514
[INFO] [stdout]   |
[INFO] [stdout] 3 | ...dv_handle))) ; assert_eq ! (unsafe { & (* (:: core :: ptr :: null :: < adv_set > ())) . duration as * const _ as usize } , 1usize , co...
[INFO] [stdout]   |                                         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]   |
[INFO] [stdout]   = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]   = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]   = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0507]: cannot move out of `self.sets` which is behind a shared reference
[INFO] [stdout]  --> /opt/rustwide/target/debug/build/apache-nimble-sys-31e8b6fd6077532c/out/bindings.rs:3:253037
[INFO] [stdout]   |
[INFO] [stdout] 3 | ...e (Debug)] pub struct ble_hci_le_set_ext_adv_enable_cp { pub enable : u8 , pub num_sets : u8 , pub sets : __IncompleteArrayField < adv_set > , ...
[INFO] [stdout]   |       ----- in this derive macro expansion                                                        ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ move occurs because `self.sets` has type `__IncompleteArrayField<adv_set>`, which does not implement the `Copy` trait
[INFO] [stdout]   |
[INFO] [stdout]   = note: `#[derive(Debug)]` triggers a move because taking references to the fields of a packed struct is undefined behaviour
[INFO] [stdout]   = note: this error originates in the derive macro `Debug` (in Nightly builds, run with -Z macro-backtrace for more info)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]  --> /opt/rustwide/target/debug/build/apache-nimble-sys-31e8b6fd6077532c/out/bindings.rs:3:254831
[INFO] [stdout]   |
[INFO] [stdout] 3 | ...sert_eq ! (unsafe { & (* (:: core :: ptr :: null :: < ble_hci_le_rd_max_adv_data_len_rp > ())) . max_adv_data_len as * const _ as usiz...
[INFO] [stdout]   |                        ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]   |
[INFO] [stdout]   = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]   = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]   = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]  --> /opt/rustwide/target/debug/build/apache-nimble-sys-31e8b6fd6077532c/out/bindings.rs:3:257568
[INFO] [stdout]   |
[INFO] [stdout] 3 | ...assert_eq ! (unsafe { & (* (:: core :: ptr :: null :: < ble_hci_le_set_periodic_adv_params_cp > ())) . min_itvl as * const _ as usize ...
[INFO] [stdout]   |                          ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]   |
[INFO] [stdout]   = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]   = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]   = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]  --> /opt/rustwide/target/debug/build/apache-nimble-sys-31e8b6fd6077532c/out/bindings.rs:3:257835
[INFO] [stdout]   |
[INFO] [stdout] 3 | ...assert_eq ! (unsafe { & (* (:: core :: ptr :: null :: < ble_hci_le_set_periodic_adv_params_cp > ())) . max_itvl as * const _ as usize ...
[INFO] [stdout]   |                          ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]   |
[INFO] [stdout]   = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]   = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]   = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]  --> /opt/rustwide/target/debug/build/apache-nimble-sys-31e8b6fd6077532c/out/bindings.rs:3:258102
[INFO] [stdout]   |
[INFO] [stdout] 3 | ...; assert_eq ! (unsafe { & (* (:: core :: ptr :: null :: < ble_hci_le_set_periodic_adv_params_cp > ())) . props as * const _ as usize }...
[INFO] [stdout]   |                            ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]   |
[INFO] [stdout]   = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]   = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]   = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0507]: cannot move out of `self.adv_data` which is behind a shared reference
[INFO] [stdout]  --> /opt/rustwide/target/debug/build/apache-nimble-sys-31e8b6fd6077532c/out/bindings.rs:3:258500
[INFO] [stdout]   |
[INFO] [stdout] 3 | ...e (Debug)] pub struct ble_hci_le_set_periodic_adv_data_cp { pub adv_handle : u8 , pub operation : u8 , pub adv_data_len : u8 , pub adv_data : __IncompleteArrayField < u8 > , ...
[INFO] [stdout]   |       ----- in this derive macro expansion                                                                                        ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ move occurs because `self.adv_data` has type `__IncompleteArrayField<u8>`, which does not implement the `Copy` trait
[INFO] [stdout]   |
[INFO] [stdout]   = note: `#[derive(Debug)]` triggers a move because taking references to the fields of a packed struct is undefined behaviour
[INFO] [stdout]   = note: this error originates in the derive macro `Debug` (in Nightly builds, run with -Z macro-backtrace for more info)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]  --> /opt/rustwide/target/debug/build/apache-nimble-sys-31e8b6fd6077532c/out/bindings.rs:3:261837
[INFO] [stdout]   |
[INFO] [stdout] 3 | ... ! (type_))) ; assert_eq ! (unsafe { & (* (:: core :: ptr :: null :: < scan_params > ())) . itvl as * const _ as usize } , 1usize , co...
[INFO] [stdout]   |                                         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]   |
[INFO] [stdout]   = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]   = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]   = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]  --> /opt/rustwide/target/debug/build/apache-nimble-sys-31e8b6fd6077532c/out/bindings.rs:3:262044
[INFO] [stdout]   |
[INFO] [stdout] 3 | ... ! (itvl))) ; assert_eq ! (unsafe { & (* (:: core :: ptr :: null :: < scan_params > ())) . window as * const _ as usize } , 3usize , c...
[INFO] [stdout]   |                                        ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]   |
[INFO] [stdout]   = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]   = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]   = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0507]: cannot move out of `self.scans` which is behind a shared reference
[INFO] [stdout]  --> /opt/rustwide/target/debug/build/apache-nimble-sys-31e8b6fd6077532c/out/bindings.rs:3:262389
[INFO] [stdout]   |
[INFO] [stdout] 3 | ...e (Debug)] pub struct ble_hci_le_set_ext_scan_params_cp { pub own_addr_type : u8 , pub filter_policy : u8 , pub phys : u8 , pub scans : __IncompleteArrayField < scan_params > , ...
[INFO] [stdout]   |       ----- in this derive macro expansion                                                                                     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ move occurs because `self.scans` has type `__IncompleteArrayField<scan_params>`, which does not implement the `Copy` trait
[INFO] [stdout]   |
[INFO] [stdout]   = note: `#[derive(Debug)]` triggers a move because taking references to the fields of a packed struct is undefined behaviour
[INFO] [stdout]   = note: this error originates in the derive macro `Debug` (in Nightly builds, run with -Z macro-backtrace for more info)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]  --> /opt/rustwide/target/debug/build/apache-nimble-sys-31e8b6fd6077532c/out/bindings.rs:3:265045
[INFO] [stdout]   |
[INFO] [stdout] 3 | ...; assert_eq ! (unsafe { & (* (:: core :: ptr :: null :: < ble_hci_le_set_ext_scan_enable_cp > ())) . duration as * const _ as usize } ...
[INFO] [stdout]   |                            ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]   |
[INFO] [stdout]   = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]   = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]   = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]  --> /opt/rustwide/target/debug/build/apache-nimble-sys-31e8b6fd6077532c/out/bindings.rs:3:265304
[INFO] [stdout]   |
[INFO] [stdout] 3 | ... ; assert_eq ! (unsafe { & (* (:: core :: ptr :: null :: < ble_hci_le_set_ext_scan_enable_cp > ())) . period as * const _ as usize } ,...
[INFO] [stdout]   |                             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]   |
[INFO] [stdout]   = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]   = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]   = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]  --> /opt/rustwide/target/debug/build/apache-nimble-sys-31e8b6fd6077532c/out/bindings.rs:3:266144
[INFO] [stdout]   |
[INFO] [stdout] 3 | ..._params))) ; assert_eq ! (unsafe { & (* (:: core :: ptr :: null :: < conn_params > ())) . scan_itvl as * const _ as usize } , 0usize ,...
[INFO] [stdout]   |                                       ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]   |
[INFO] [stdout]   = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]   = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]   = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]  --> /opt/rustwide/target/debug/build/apache-nimble-sys-31e8b6fd6077532c/out/bindings.rs:3:266361
[INFO] [stdout]   |
[INFO] [stdout] 3 | ...n_itvl))) ; assert_eq ! (unsafe { & (* (:: core :: ptr :: null :: < conn_params > ())) . scan_window as * const _ as usize } , 2usize ...
[INFO] [stdout]   |                                      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]   |
[INFO] [stdout]   = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]   = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]   = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]  --> /opt/rustwide/target/debug/build/apache-nimble-sys-31e8b6fd6077532c/out/bindings.rs:3:266582
[INFO] [stdout]   |
[INFO] [stdout] 3 | ...indow))) ; assert_eq ! (unsafe { & (* (:: core :: ptr :: null :: < conn_params > ())) . conn_min_itvl as * const _ as usize } , 4usize...
[INFO] [stdout]   |                                     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]   |
[INFO] [stdout]   = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]   = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]   = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]  --> /opt/rustwide/target/debug/build/apache-nimble-sys-31e8b6fd6077532c/out/bindings.rs:3:266807
[INFO] [stdout]   |
[INFO] [stdout] 3 | ..._itvl))) ; assert_eq ! (unsafe { & (* (:: core :: ptr :: null :: < conn_params > ())) . conn_max_itvl as * const _ as usize } , 6usize...
[INFO] [stdout]   |                                     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]   |
[INFO] [stdout]   = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]   = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]   = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]  --> /opt/rustwide/target/debug/build/apache-nimble-sys-31e8b6fd6077532c/out/bindings.rs:3:267032
[INFO] [stdout]   |
[INFO] [stdout] 3 | ..._itvl))) ; assert_eq ! (unsafe { & (* (:: core :: ptr :: null :: < conn_params > ())) . conn_latency as * const _ as usize } , 8usize ...
[INFO] [stdout]   |                                     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]   |
[INFO] [stdout]   = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]   = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]   = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]  --> /opt/rustwide/target/debug/build/apache-nimble-sys-31e8b6fd6077532c/out/bindings.rs:3:267255
[INFO] [stdout]   |
[INFO] [stdout] 3 | ...cy))) ; assert_eq ! (unsafe { & (* (:: core :: ptr :: null :: < conn_params > ())) . supervision_timeout as * const _ as usize } , 10u...
[INFO] [stdout]   |                                  ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]   |
[INFO] [stdout]   = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]   = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]   = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]  --> /opt/rustwide/target/debug/build/apache-nimble-sys-31e8b6fd6077532c/out/bindings.rs:3:267493
[INFO] [stdout]   |
[INFO] [stdout] 3 | ..._timeout))) ; assert_eq ! (unsafe { & (* (:: core :: ptr :: null :: < conn_params > ())) . min_ce as * const _ as usize } , 12usize , ...
[INFO] [stdout]   |                                        ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]   |
[INFO] [stdout]   = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]   = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]   = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]  --> /opt/rustwide/target/debug/build/apache-nimble-sys-31e8b6fd6077532c/out/bindings.rs:3:267705
[INFO] [stdout]   |
[INFO] [stdout] 3 | ... (min_ce))) ; assert_eq ! (unsafe { & (* (:: core :: ptr :: null :: < conn_params > ())) . max_ce as * const _ as usize } , 14usize , ...
[INFO] [stdout]   |                                        ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]   |
[INFO] [stdout]   = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]   = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]   = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0507]: cannot move out of `self.conn_params` which is behind a shared reference
[INFO] [stdout]  --> /opt/rustwide/target/debug/build/apache-nimble-sys-31e8b6fd6077532c/out/bindings.rs:3:268114
[INFO] [stdout]   |
[INFO] [stdout] 3 | ...e (Debug)] pub struct ble_hci_le_ext_create_conn_cp { pub filter_policy : u8 , pub own_addr_type : u8 , pub peer_addr_type : u8 , pub peer_addr : [u8 ; 6usize] , pub init_phy_mask : u8 , pub conn_params : __IncompleteArrayField < conn_params > , ...
[INFO] [stdout]   |       ----- in this derive macro expansion                                                                                                                                                    ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ move occurs because `self.conn_params` has type `__IncompleteArrayField<conn_params>`, which does not implement the `Copy` trait
[INFO] [stdout]   |
[INFO] [stdout]   = note: `#[derive(Debug)]` triggers a move because taking references to the fields of a packed struct is undefined behaviour
[INFO] [stdout]   = note: this error originates in the derive macro `Debug` (in Nightly builds, run with -Z macro-backtrace for more info)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]  --> /opt/rustwide/target/debug/build/apache-nimble-sys-31e8b6fd6077532c/out/bindings.rs:3:271942
[INFO] [stdout]   |
[INFO] [stdout] 3 | ...; assert_eq ! (unsafe { & (* (:: core :: ptr :: null :: < ble_hci_le_periodic_adv_create_sync_cp > ())) . skip as * const _ as usize }...
[INFO] [stdout]   |                            ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]   |
[INFO] [stdout]   = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]   = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]   = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]  --> /opt/rustwide/target/debug/build/apache-nimble-sys-31e8b6fd6077532c/out/bindings.rs:3:272203
[INFO] [stdout]   |
[INFO] [stdout] 3 | ...sert_eq ! (unsafe { & (* (:: core :: ptr :: null :: < ble_hci_le_periodic_adv_create_sync_cp > ())) . sync_timeout as * const _ as usi...
[INFO] [stdout]   |                        ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]   |
[INFO] [stdout]   = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]   = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]   = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]  --> /opt/rustwide/target/debug/build/apache-nimble-sys-31e8b6fd6077532c/out/bindings.rs:3:273326
[INFO] [stdout]   |
[INFO] [stdout] 3 | ...ssert_eq ! (unsafe { & (* (:: core :: ptr :: null :: < ble_hci_le_periodic_adv_term_sync_cp > ())) . sync_handle as * const _ as usize...
[INFO] [stdout]   |                         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]   |
[INFO] [stdout]   = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]   = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]   = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]  --> /opt/rustwide/target/debug/build/apache-nimble-sys-31e8b6fd6077532c/out/bindings.rs:3:279142
[INFO] [stdout]   |
[INFO] [stdout] 3 | ..._eq ! (unsafe { & (* (:: core :: ptr :: null :: < ble_hci_le_rd_rf_path_compensation_rp > ())) . tx_path_compensation as * const _ as ...
[INFO] [stdout]   |                    ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]   |
[INFO] [stdout]   = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]   = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]   = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]  --> /opt/rustwide/target/debug/build/apache-nimble-sys-31e8b6fd6077532c/out/bindings.rs:3:279433
[INFO] [stdout]   |
[INFO] [stdout] 3 | ..._eq ! (unsafe { & (* (:: core :: ptr :: null :: < ble_hci_le_rd_rf_path_compensation_rp > ())) . rx_path_compensation as * const _ as ...
[INFO] [stdout]   |                    ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]   |
[INFO] [stdout]   = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]   = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]   = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]  --> /opt/rustwide/target/debug/build/apache-nimble-sys-31e8b6fd6077532c/out/bindings.rs:3:280337
[INFO] [stdout]   |
[INFO] [stdout] 3 | ..._eq ! (unsafe { & (* (:: core :: ptr :: null :: < ble_hci_le_wr_rf_path_compensation_cp > ())) . tx_path_compensation as * const _ as ...
[INFO] [stdout]   |                    ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]   |
[INFO] [stdout]   = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]   = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]   = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]  --> /opt/rustwide/target/debug/build/apache-nimble-sys-31e8b6fd6077532c/out/bindings.rs:3:280628
[INFO] [stdout]   |
[INFO] [stdout] 3 | ..._eq ! (unsafe { & (* (:: core :: ptr :: null :: < ble_hci_le_wr_rf_path_compensation_cp > ())) . rx_path_compensation as * const _ as ...
[INFO] [stdout]   |                    ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]   |
[INFO] [stdout]   = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]   = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]   = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]  --> /opt/rustwide/target/debug/build/apache-nimble-sys-31e8b6fd6077532c/out/bindings.rs:3:282894
[INFO] [stdout]   |
[INFO] [stdout] 3 | ...ert_eq ! (unsafe { & (* (:: core :: ptr :: null :: < ble_hci_le_periodic_adv_receive_enable_cp > ())) . sync_handle as * const _ as us...
[INFO] [stdout]   |                       ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]   |
[INFO] [stdout]   = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]   = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]   = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]  --> /opt/rustwide/target/debug/build/apache-nimble-sys-31e8b6fd6077532c/out/bindings.rs:3:284084
[INFO] [stdout]   |
[INFO] [stdout] 3 | ...ert_eq ! (unsafe { & (* (:: core :: ptr :: null :: < ble_hci_le_periodic_adv_sync_transfer_cp > ())) . conn_handle as * const _ as usi...
[INFO] [stdout]   |                       ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]   |
[INFO] [stdout]   = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]   = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]   = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]  --> /opt/rustwide/target/debug/build/apache-nimble-sys-31e8b6fd6077532c/out/bindings.rs:3:284363
[INFO] [stdout]   |
[INFO] [stdout] 3 | ...ert_eq ! (unsafe { & (* (:: core :: ptr :: null :: < ble_hci_le_periodic_adv_sync_transfer_cp > ())) . service_data as * const _ as us...
[INFO] [stdout]   |                       ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]   |
[INFO] [stdout]   = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]   = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]   = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]  --> /opt/rustwide/target/debug/build/apache-nimble-sys-31e8b6fd6077532c/out/bindings.rs:3:284644
[INFO] [stdout]   |
[INFO] [stdout] 3 | ...ert_eq ! (unsafe { & (* (:: core :: ptr :: null :: < ble_hci_le_periodic_adv_sync_transfer_cp > ())) . sync_handle as * const _ as usi...
[INFO] [stdout]   |                       ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]   |
[INFO] [stdout]   = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]   = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]   = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]  --> /opt/rustwide/target/debug/build/apache-nimble-sys-31e8b6fd6077532c/out/bindings.rs:3:285512
[INFO] [stdout]   |
[INFO] [stdout] 3 | ...ert_eq ! (unsafe { & (* (:: core :: ptr :: null :: < ble_hci_le_periodic_adv_sync_transfer_rp > ())) . conn_handle as * const _ as usi...
[INFO] [stdout]   |                       ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]   |
[INFO] [stdout]   = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]   = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]   = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]  --> /opt/rustwide/target/debug/build/apache-nimble-sys-31e8b6fd6077532c/out/bindings.rs:3:286451
[INFO] [stdout]   |
[INFO] [stdout] 3 | ...t_eq ! (unsafe { & (* (:: core :: ptr :: null :: < ble_hci_le_periodic_adv_set_info_transfer_cp > ())) . conn_handle as * const _ as u...
[INFO] [stdout]   |                     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]   |
[INFO] [stdout]   = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]   = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]   = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]  --> /opt/rustwide/target/debug/build/apache-nimble-sys-31e8b6fd6077532c/out/bindings.rs:3:286738
[INFO] [stdout]   |
[INFO] [stdout] 3 | ...t_eq ! (unsafe { & (* (:: core :: ptr :: null :: < ble_hci_le_periodic_adv_set_info_transfer_cp > ())) . service_data as * const _ as ...
[INFO] [stdout]   |                     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]   |
[INFO] [stdout]   = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]   = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]   = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]  --> /opt/rustwide/target/debug/build/apache-nimble-sys-31e8b6fd6077532c/out/bindings.rs:3:287925
[INFO] [stdout]   |
[INFO] [stdout] 3 | ...t_eq ! (unsafe { & (* (:: core :: ptr :: null :: < ble_hci_le_periodic_adv_set_info_transfer_rp > ())) . conn_handle as * const _ as u...
[INFO] [stdout]   |                     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]   |
[INFO] [stdout]   = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]   = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]   = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]  --> /opt/rustwide/target/debug/build/apache-nimble-sys-31e8b6fd6077532c/out/bindings.rs:3:288926
[INFO] [stdout]   |
[INFO] [stdout] 3 | ..._eq ! (unsafe { & (* (:: core :: ptr :: null :: < ble_hci_le_periodic_adv_sync_transfer_params_cp > ())) . conn_handle as * const _ as...
[INFO] [stdout]   |                    ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]   |
[INFO] [stdout]   = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]   = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]   = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]  --> /opt/rustwide/target/debug/build/apache-nimble-sys-31e8b6fd6077532c/out/bindings.rs:3:289498
[INFO] [stdout]   |
[INFO] [stdout] 3 | ...ert_eq ! (unsafe { & (* (:: core :: ptr :: null :: < ble_hci_le_periodic_adv_sync_transfer_params_cp > ())) . skip as * const _ as usi...
[INFO] [stdout]   |                       ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]   |
[INFO] [stdout]   = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]   = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]   = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]  --> /opt/rustwide/target/debug/build/apache-nimble-sys-31e8b6fd6077532c/out/bindings.rs:3:289777
[INFO] [stdout]   |
[INFO] [stdout] 3 | ...eq ! (unsafe { & (* (:: core :: ptr :: null :: < ble_hci_le_periodic_adv_sync_transfer_params_cp > ())) . sync_timeout as * const _ as...
[INFO] [stdout]   |                   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]   |
[INFO] [stdout]   = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]   = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]   = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]  --> /opt/rustwide/target/debug/build/apache-nimble-sys-31e8b6fd6077532c/out/bindings.rs:3:291000
[INFO] [stdout]   |
[INFO] [stdout] 3 | ..._eq ! (unsafe { & (* (:: core :: ptr :: null :: < ble_hci_le_periodic_adv_sync_transfer_params_rp > ())) . conn_handle as * const _ as...
[INFO] [stdout]   |                    ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]   |
[INFO] [stdout]   = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]   = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]   = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]  --> /opt/rustwide/target/debug/build/apache-nimble-sys-31e8b6fd6077532c/out/bindings.rs:3:292326
[INFO] [stdout]   |
[INFO] [stdout] 3 | ...eq ! (unsafe { & (* (:: core :: ptr :: null :: < ble_hci_le_set_default_periodic_sync_transfer_params_cp > ())) . skip as * const _ as...
[INFO] [stdout]   |                   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]   |
[INFO] [stdout]   = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]   = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]   = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]  --> /opt/rustwide/target/debug/build/apache-nimble-sys-31e8b6fd6077532c/out/bindings.rs:3:292621
[INFO] [stdout]   |
[INFO] [stdout] 3 | ... (unsafe { & (* (:: core :: ptr :: null :: < ble_hci_le_set_default_periodic_sync_transfer_params_cp > ())) . sync_timeout as * const ...
[INFO] [stdout]   |               ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]   |
[INFO] [stdout]   = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]   = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]   = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]  --> /opt/rustwide/target/debug/build/apache-nimble-sys-31e8b6fd6077532c/out/bindings.rs:3:293774
[INFO] [stdout]   |
[INFO] [stdout] 3 | ...; assert_eq ! (unsafe { & (* (:: core :: ptr :: null :: < ble_hci_le_request_peer_sca_cp > ())) . conn_handle as * const _ as usize } ...
[INFO] [stdout]   |                            ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]   |
[INFO] [stdout]   = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]   = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]   = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]  --> /opt/rustwide/target/debug/build/apache-nimble-sys-31e8b6fd6077532c/out/bindings.rs:3:295786
[INFO] [stdout]   |
[INFO] [stdout] 3 | ...))) ; assert_eq ! (unsafe { & (* (:: core :: ptr :: null :: < ble_hci_ev_disconn_cmp > ())) . conn_handle as * const _ as usize } , 1u...
[INFO] [stdout]   |                                ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]   |
[INFO] [stdout]   = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]   = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]   = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]  --> /opt/rustwide/target/debug/build/apache-nimble-sys-31e8b6fd6077532c/out/bindings.rs:3:297011
[INFO] [stdout]   |
[INFO] [stdout] 3 | ...) ; assert_eq ! (unsafe { & (* (:: core :: ptr :: null :: < ble_hci_ev_enrypt_chg > ())) . connection_handle as * const _ as usize } ,...
[INFO] [stdout]   |                              ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]   |
[INFO] [stdout]   = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]   = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]   = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]  --> /opt/rustwide/target/debug/build/apache-nimble-sys-31e8b6fd6077532c/out/bindings.rs:3:298360
[INFO] [stdout]   |
[INFO] [stdout] 3 | ...; assert_eq ! (unsafe { & (* (:: core :: ptr :: null :: < ble_hci_ev_rd_rem_ver_info_cmp > ())) . conn_handle as * const _ as usize } ...
[INFO] [stdout]   |                            ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]   |
[INFO] [stdout]   = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]   = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]   = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]  --> /opt/rustwide/target/debug/build/apache-nimble-sys-31e8b6fd6077532c/out/bindings.rs:3:298870
[INFO] [stdout]   |
[INFO] [stdout] 3 | ...; assert_eq ! (unsafe { & (* (:: core :: ptr :: null :: < ble_hci_ev_rd_rem_ver_info_cmp > ())) . manufacturer as * const _ as usize }...
[INFO] [stdout]   |                            ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]   |
[INFO] [stdout]   = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]   = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]   = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]  --> /opt/rustwide/target/debug/build/apache-nimble-sys-31e8b6fd6077532c/out/bindings.rs:3:299131
[INFO] [stdout]   |
[INFO] [stdout] 3 | ... ; assert_eq ! (unsafe { & (* (:: core :: ptr :: null :: < ble_hci_ev_rd_rem_ver_info_cmp > ())) . subversion as * const _ as usize } ...
[INFO] [stdout]   |                             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]   |
[INFO] [stdout]   = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]   = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]   = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0507]: cannot move out of `self.return_params` which is behind a shared reference
[INFO] [stdout]  --> /opt/rustwide/target/debug/build/apache-nimble-sys-31e8b6fd6077532c/out/bindings.rs:3:299510
[INFO] [stdout]   |
[INFO] [stdout] 3 | ...e (Debug)] pub struct ble_hci_ev_command_complete { pub num_packets : u8 , pub opcode : u16 , pub status : u8 , pub return_params : __IncompleteArrayField < u8 > , ...
[INFO] [stdout]   |       ----- in this derive macro expansion                                                                         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ move occurs because `self.return_params` has type `__IncompleteArrayField<u8>`, which does not implement the `Copy` trait
[INFO] [stdout]   |
[INFO] [stdout]   = note: `#[derive(Debug)]` triggers a move because taking references to the fields of a packed struct is undefined behaviour
[INFO] [stdout]   = note: this error originates in the derive macro `Debug` (in Nightly builds, run with -Z macro-backtrace for more info)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]  --> /opt/rustwide/target/debug/build/apache-nimble-sys-31e8b6fd6077532c/out/bindings.rs:3:300225
[INFO] [stdout]   |
[INFO] [stdout] 3 | ...))) ; assert_eq ! (unsafe { & (* (:: core :: ptr :: null :: < ble_hci_ev_command_complete > ())) . opcode as * const _ as usize } , 1u...
[INFO] [stdout]   |                                ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]   |
[INFO] [stdout]   = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]   = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]   = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]  --> /opt/rustwide/target/debug/build/apache-nimble-sys-31e8b6fd6077532c/out/bindings.rs:3:301782
[INFO] [stdout]   |
[INFO] [stdout] 3 | ...) ; assert_eq ! (unsafe { & (* (:: core :: ptr :: null :: < ble_hci_ev_command_complete_nop > ())) . opcode as * const _ as usize } , ...
[INFO] [stdout]   |                              ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]   |
[INFO] [stdout]   = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]   = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]   = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]  --> /opt/rustwide/target/debug/build/apache-nimble-sys-31e8b6fd6077532c/out/bindings.rs:3:303056
[INFO] [stdout]   |
[INFO] [stdout] 3 | ...s))) ; assert_eq ! (unsafe { & (* (:: core :: ptr :: null :: < ble_hci_ev_command_status > ())) . opcode as * const _ as usize } , 2us...
[INFO] [stdout]   |                                 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]   |
[INFO] [stdout]   = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]   = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]   = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]  --> /opt/rustwide/target/debug/build/apache-nimble-sys-31e8b6fd6077532c/out/bindings.rs:3:304394
[INFO] [stdout]   |
[INFO] [stdout] 3 | ... (comp_pkt))) ; assert_eq ! (unsafe { & (* (:: core :: ptr :: null :: < comp_pkt > ())) . handle as * const _ as usize } , 0usize , co...
[INFO] [stdout]   |                                          ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]   |
[INFO] [stdout]   = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]   = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]   = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]  --> /opt/rustwide/target/debug/build/apache-nimble-sys-31e8b6fd6077532c/out/bindings.rs:3:304599
[INFO] [stdout]   |
[INFO] [stdout] 3 | ...! (handle))) ; assert_eq ! (unsafe { & (* (:: core :: ptr :: null :: < comp_pkt > ())) . packets as * const _ as usize } , 2usize , co...
[INFO] [stdout]   |                                         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]   |
[INFO] [stdout]   = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]   = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]   = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0507]: cannot move out of `self.completed` which is behind a shared reference
[INFO] [stdout]  --> /opt/rustwide/target/debug/build/apache-nimble-sys-31e8b6fd6077532c/out/bindings.rs:3:304882
[INFO] [stdout]   |
[INFO] [stdout] 3 | ...erive (Debug)] pub struct ble_hci_ev_num_comp_pkts { pub count : u8 , pub completed : __IncompleteArrayField < comp_pkt > , } # [test]...
[INFO] [stdout]   |           ----- in this derive macro expansion                           ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ move occurs because `self.completed` has type `__IncompleteArrayField<comp_pkt>`, which does not implement the `Copy` trait
[INFO] [stdout]   |
[INFO] [stdout]   = note: `#[derive(Debug)]` triggers a move because taking references to the fields of a packed struct is undefined behaviour
[INFO] [stdout]   = note: this error originates in the derive macro `Debug` (in Nightly builds, run with -Z macro-backtrace for more info)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]  --> /opt/rustwide/target/debug/build/apache-nimble-sys-31e8b6fd6077532c/out/bindings.rs:3:307338
[INFO] [stdout]   |
[INFO] [stdout] 3 | ...) ; assert_eq ! (unsafe { & (* (:: core :: ptr :: null :: < ble_hci_ev_enc_key_refresh > ())) . conn_handle as * const _ as usize } , ...
[INFO] [stdout]   |                              ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]   |
[INFO] [stdout]   = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]   = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]   = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0507]: cannot move out of `self.data` which is behind a shared reference
[INFO] [stdout]  --> /opt/rustwide/target/debug/build/apache-nimble-sys-31e8b6fd6077532c/out/bindings.rs:3:307662
[INFO] [stdout]   |
[INFO] [stdout] 3 | ...] # [derive (Debug)] pub struct ble_hci_ev_le_meta { pub subevent : u8 , pub data : __IncompleteArrayField < u8 > , } # [test] fn bind...
[INFO] [stdout]   |                 ----- in this derive macro expansion                        ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ move occurs because `self.data` has type `__IncompleteArrayField<u8>`, which does not implement the `Copy` trait
[INFO] [stdout]   |
[INFO] [stdout]   = note: `#[derive(Debug)]` triggers a move because taking references to the fields of a packed struct is undefined behaviour
[INFO] [stdout]   = note: this error originates in the derive macro `Debug` (in Nightly builds, run with -Z macro-backtrace for more info)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]  --> /opt/rustwide/target/debug/build/apache-nimble-sys-31e8b6fd6077532c/out/bindings.rs:3:309013
[INFO] [stdout]   |
[INFO] [stdout] 3 | ...)) ; assert_eq ! (unsafe { & (* (:: core :: ptr :: null :: < ble_hci_ev_auth_pyld_tmo > ())) . conn_handle as * const _ as usize } , 0...
[INFO] [stdout]   |                               ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]   |
[INFO] [stdout]   = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]   = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]   = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0507]: cannot move out of `self.data` which is behind a shared reference
[INFO] [stdout]  --> /opt/rustwide/target/debug/build/apache-nimble-sys-31e8b6fd6077532c/out/bindings.rs:3:309332
[INFO] [stdout]   |
[INFO] [stdout] 3 | ...] # [derive (Debug)] pub struct ble_hci_ev_vendor_debug { pub id : u8 , pub data : __IncompleteArrayField < u8 > , } # [test] fn bindg...
[INFO] [stdout]   |                 ----- in this derive macro expansion                       ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ move occurs because `self.data` has type `__IncompleteArrayField<u8>`, which does not implement the `Copy` trait
[INFO] [stdout]   |
[INFO] [stdout]   = note: `#[derive(Debug)]` triggers a move because taking references to the fields of a packed struct is undefined behaviour
[INFO] [stdout]   = note: this error originates in the derive macro `Debug` (in Nightly builds, run with -Z macro-backtrace for more info)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]  --> /opt/rustwide/target/debug/build/apache-nimble-sys-31e8b6fd6077532c/out/bindings.rs:3:311497
[INFO] [stdout]   |
[INFO] [stdout] 3 | ... assert_eq ! (unsafe { & (* (:: core :: ptr :: null :: < ble_hci_ev_le_subev_conn_complete > ())) . conn_handle as * const _ as usize ...
[INFO] [stdout]   |                           ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]   |
[INFO] [stdout]   = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]   = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]   = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]  --> /opt/rustwide/target/debug/build/apache-nimble-sys-31e8b6fd6077532c/out/bindings.rs:3:312545
[INFO] [stdout]   |
[INFO] [stdout] 3 | ...; assert_eq ! (unsafe { & (* (:: core :: ptr :: null :: < ble_hci_ev_le_subev_conn_complete > ())) . conn_itvl as * const _ as usize }...
[INFO] [stdout]   |                            ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]   |
[INFO] [stdout]   = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]   = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]   = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]  --> /opt/rustwide/target/debug/build/apache-nimble-sys-31e8b6fd6077532c/out/bindings.rs:3:312807
[INFO] [stdout]   |
[INFO] [stdout] 3 | ...assert_eq ! (unsafe { & (* (:: core :: ptr :: null :: < ble_hci_ev_le_subev_conn_complete > ())) . conn_latency as * const _ as usize ...
[INFO] [stdout]   |                          ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]   |
[INFO] [stdout]   = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]   = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]   = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]  --> /opt/rustwide/target/debug/build/apache-nimble-sys-31e8b6fd6077532c/out/bindings.rs:3:313075
[INFO] [stdout]   |
[INFO] [stdout] 3 | ...ert_eq ! (unsafe { & (* (:: core :: ptr :: null :: < ble_hci_ev_le_subev_conn_complete > ())) . supervision_timeout as * const _ as us...
[INFO] [stdout]   |                       ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]   |
[INFO] [stdout]   = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]   = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]   = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0507]: cannot move out of `self.data` which is behind a shared reference
[INFO] [stdout]  --> /opt/rustwide/target/debug/build/apache-nimble-sys-31e8b6fd6077532c/out/bindings.rs:3:313737
[INFO] [stdout]   |
[INFO] [stdout] 3 | ...e (Debug)] pub struct adv_report { pub type_ : u8 , pub addr_type : u8 , pub addr : [u8 ; 6usize] , pub data_len : u8 , pub data : __IncompleteArrayField < u8 > , ...
[INFO] [stdout]   |       ----- in this derive macro expansion                                                                                 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ move occurs because `self.data` has type `__IncompleteArrayField<u8>`, which does not implement the `Copy` trait
[INFO] [stdout]   |
[INFO] [stdout]   = note: `#[derive(Debug)]` triggers a move because taking references to the fields of a packed struct is undefined behaviour
[INFO] [stdout]   = note: this error originates in the derive macro `Debug` (in Nightly builds, run with -Z macro-backtrace for more info)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0507]: cannot move out of `self.reports` which is behind a shared reference
[INFO] [stdout]  --> /opt/rustwide/target/debug/build/apache-nimble-sys-31e8b6fd6077532c/out/bindings.rs:3:315257
[INFO] [stdout]   |
[INFO] [stdout] 3 | ...e (Debug)] pub struct ble_hci_ev_le_subev_adv_rpt { pub subev_code : u8 , pub num_reports : u8 , pub reports : __IncompleteArrayField < adv_report > , ...
[INFO] [stdout]   |       ----- in this derive macro expansion                                                          ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ move occurs because `self.reports` has type `__IncompleteArrayField<adv_report>`, which does not implement the `Copy` trait
[INFO] [stdout]   |
[INFO] [stdout]   = note: `#[derive(Debug)]` triggers a move because taking references to the fields of a packed struct is undefined behaviour
[INFO] [stdout]   = note: this error originates in the derive macro `Debug` (in Nightly builds, run with -Z macro-backtrace for more info)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]  --> /opt/rustwide/target/debug/build/apache-nimble-sys-31e8b6fd6077532c/out/bindings.rs:3:317695
[INFO] [stdout]   |
[INFO] [stdout] 3 | ...ssert_eq ! (unsafe { & (* (:: core :: ptr :: null :: < ble_hci_ev_le_subev_conn_upd_complete > ())) . conn_handle as * const _ as usiz...
[INFO] [stdout]   |                         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]   |
[INFO] [stdout]   = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]   = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]   = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]  --> /opt/rustwide/target/debug/build/apache-nimble-sys-31e8b6fd6077532c/out/bindings.rs:3:317968
[INFO] [stdout]   |
[INFO] [stdout] 3 | ...assert_eq ! (unsafe { & (* (:: core :: ptr :: null :: < ble_hci_ev_le_subev_conn_upd_complete > ())) . conn_itvl as * const _ as usize...
[INFO] [stdout]   |                          ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]   |
[INFO] [stdout]   = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]   = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]   = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]  --> /opt/rustwide/target/debug/build/apache-nimble-sys-31e8b6fd6077532c/out/bindings.rs:3:318237
[INFO] [stdout]   |
[INFO] [stdout] 3 | ...sert_eq ! (unsafe { & (* (:: core :: ptr :: null :: < ble_hci_ev_le_subev_conn_upd_complete > ())) . conn_latency as * const _ as usiz...
[INFO] [stdout]   |                        ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]   |
[INFO] [stdout]   = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]   = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]   = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]  --> /opt/rustwide/target/debug/build/apache-nimble-sys-31e8b6fd6077532c/out/bindings.rs:3:318512
[INFO] [stdout]   |
[INFO] [stdout] 3 | ...t_eq ! (unsafe { & (* (:: core :: ptr :: null :: < ble_hci_ev_le_subev_conn_upd_complete > ())) . supervision_timeout as * const _ as ...
[INFO] [stdout]   |                     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]   |
[INFO] [stdout]   = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]   = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]   = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]  --> /opt/rustwide/target/debug/build/apache-nimble-sys-31e8b6fd6077532c/out/bindings.rs:3:319968
[INFO] [stdout]   |
[INFO] [stdout] 3 | ...ssert_eq ! (unsafe { & (* (:: core :: ptr :: null :: < ble_hci_ev_le_subev_rd_rem_used_feat > ())) . conn_handle as * const _ as usize...
[INFO] [stdout]   |                         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]   |
[INFO] [stdout]   = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]   = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]   = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]  --> /opt/rustwide/target/debug/build/apache-nimble-sys-31e8b6fd6077532c/out/bindings.rs:3:321346
[INFO] [stdout]   |
[INFO] [stdout] 3 | ...; assert_eq ! (unsafe { & (* (:: core :: ptr :: null :: < ble_hci_ev_le_subev_lt_key_req > ())) . conn_handle as * const _ as usize } ...
[INFO] [stdout]   |                            ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]   |
[INFO] [stdout]   = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]   = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]   = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]  --> /opt/rustwide/target/debug/build/apache-nimble-sys-31e8b6fd6077532c/out/bindings.rs:3:321605
[INFO] [stdout]   |
[INFO] [stdout] 3 | ...))) ; assert_eq ! (unsafe { & (* (:: core :: ptr :: null :: < ble_hci_ev_le_subev_lt_key_req > ())) . rand as * const _ as usize } , 3...
[INFO] [stdout]   |                                ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]   |
[INFO] [stdout]   = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]   = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]   = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]  --> /opt/rustwide/target/debug/build/apache-nimble-sys-31e8b6fd6077532c/out/bindings.rs:3:321850
[INFO] [stdout]   |
[INFO] [stdout] 3 | ...))) ; assert_eq ! (unsafe { & (* (:: core :: ptr :: null :: < ble_hci_ev_le_subev_lt_key_req > ())) . div as * const _ as usize } , 11...
[INFO] [stdout]   |                                ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]   |
[INFO] [stdout]   = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]   = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]   = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]  --> /opt/rustwide/target/debug/build/apache-nimble-sys-31e8b6fd6077532c/out/bindings.rs:3:323057
[INFO] [stdout]   |
[INFO] [stdout] 3 | ...sert_eq ! (unsafe { & (* (:: core :: ptr :: null :: < ble_hci_ev_le_subev_rem_conn_param_req > ())) . conn_handle as * const _ as usiz...
[INFO] [stdout]   |                        ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]   |
[INFO] [stdout]   = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]   = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]   = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]  --> /opt/rustwide/target/debug/build/apache-nimble-sys-31e8b6fd6077532c/out/bindings.rs:3:323332
[INFO] [stdout]   |
[INFO] [stdout] 3 | ...sert_eq ! (unsafe { & (* (:: core :: ptr :: null :: < ble_hci_ev_le_subev_rem_conn_param_req > ())) . min_interval as * const _ as usi...
[INFO] [stdout]   |                        ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]   |
[INFO] [stdout]   = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]   = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]   = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]  --> /opt/rustwide/target/debug/build/apache-nimble-sys-31e8b6fd6077532c/out/bindings.rs:3:323609
[INFO] [stdout]   |
[INFO] [stdout] 3 | ...sert_eq ! (unsafe { & (* (:: core :: ptr :: null :: < ble_hci_ev_le_subev_rem_conn_param_req > ())) . max_interval as * const _ as usi...
[INFO] [stdout]   |                        ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]   |
[INFO] [stdout]   = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]   = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]   = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]  --> /opt/rustwide/target/debug/build/apache-nimble-sys-31e8b6fd6077532c/out/bindings.rs:3:323886
[INFO] [stdout]   |
[INFO] [stdout] 3 | ...assert_eq ! (unsafe { & (* (:: core :: ptr :: null :: < ble_hci_ev_le_subev_rem_conn_param_req > ())) . latency as * const _ as usize ...
[INFO] [stdout]   |                          ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]   |
[INFO] [stdout]   = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]   = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]   = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]  --> /opt/rustwide/target/debug/build/apache-nimble-sys-31e8b6fd6077532c/out/bindings.rs:3:324153
[INFO] [stdout]   |
[INFO] [stdout] 3 | ...assert_eq ! (unsafe { & (* (:: core :: ptr :: null :: < ble_hci_ev_le_subev_rem_conn_param_req > ())) . timeout as * const _ as usize ...
[INFO] [stdout]   |                          ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]   |
[INFO] [stdout]   = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]   = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]   = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]  --> /opt/rustwide/target/debug/build/apache-nimble-sys-31e8b6fd6077532c/out/bindings.rs:3:325345
[INFO] [stdout]   |
[INFO] [stdout] 3 | ... assert_eq ! (unsafe { & (* (:: core :: ptr :: null :: < ble_hci_ev_le_subev_data_len_chg > ())) . conn_handle as * const _ as usize }...
[INFO] [stdout]   |                           ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]   |
[INFO] [stdout]   = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]   = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]   = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]  --> /opt/rustwide/target/debug/build/apache-nimble-sys-31e8b6fd6077532c/out/bindings.rs:3:325608
[INFO] [stdout]   |
[INFO] [stdout] 3 | ...assert_eq ! (unsafe { & (* (:: core :: ptr :: null :: < ble_hci_ev_le_subev_data_len_chg > ())) . max_tx_octets as * const _ as usize ...
[INFO] [stdout]   |                          ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]   |
[INFO] [stdout]   = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]   = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]   = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]  --> /opt/rustwide/target/debug/build/apache-nimble-sys-31e8b6fd6077532c/out/bindings.rs:3:325875
[INFO] [stdout]   |
[INFO] [stdout] 3 | ... assert_eq ! (unsafe { & (* (:: core :: ptr :: null :: < ble_hci_ev_le_subev_data_len_chg > ())) . max_tx_time as * const _ as usize }...
[INFO] [stdout]   |                           ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]   |
[INFO] [stdout]   = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]   = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]   = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]  --> /opt/rustwide/target/debug/build/apache-nimble-sys-31e8b6fd6077532c/out/bindings.rs:3:326138
[INFO] [stdout]   |
[INFO] [stdout] 3 | ...assert_eq ! (unsafe { & (* (:: core :: ptr :: null :: < ble_hci_ev_le_subev_data_len_chg > ())) . max_rx_octets as * const _ as usize ...
[INFO] [stdout]   |                          ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]   |
[INFO] [stdout]   = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]   = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]   = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]  --> /opt/rustwide/target/debug/build/apache-nimble-sys-31e8b6fd6077532c/out/bindings.rs:3:326405
[INFO] [stdout]   |
[INFO] [stdout] 3 | ... assert_eq ! (unsafe { & (* (:: core :: ptr :: null :: < ble_hci_ev_le_subev_data_len_chg > ())) . max_rx_time as * const _ as usize }...
[INFO] [stdout]   |                           ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]   |
[INFO] [stdout]   = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]   = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]   = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]  --> /opt/rustwide/target/debug/build/apache-nimble-sys-31e8b6fd6077532c/out/bindings.rs:3:330903
[INFO] [stdout]   |
[INFO] [stdout] 3 | ...ssert_eq ! (unsafe { & (* (:: core :: ptr :: null :: < ble_hci_ev_le_subev_enh_conn_complete > ())) . conn_handle as * const _ as usiz...
[INFO] [stdout]   |                         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]   |
[INFO] [stdout]   = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]   = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]   = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]  --> /opt/rustwide/target/debug/build/apache-nimble-sys-31e8b6fd6077532c/out/bindings.rs:3:332521
[INFO] [stdout]   |
[INFO] [stdout] 3 | ...assert_eq ! (unsafe { & (* (:: core :: ptr :: null :: < ble_hci_ev_le_subev_enh_conn_complete > ())) . conn_itvl as * const _ as usize...
[INFO] [stdout]   |                          ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]   |
[INFO] [stdout]   = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]   = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]   = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]  --> /opt/rustwide/target/debug/build/apache-nimble-sys-31e8b6fd6077532c/out/bindings.rs:3:332791
[INFO] [stdout]   |
[INFO] [stdout] 3 | ...sert_eq ! (unsafe { & (* (:: core :: ptr :: null :: < ble_hci_ev_le_subev_enh_conn_complete > ())) . conn_latency as * const _ as usiz...
[INFO] [stdout]   |                        ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]   |
[INFO] [stdout]   = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]   = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]   = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]  --> /opt/rustwide/target/debug/build/apache-nimble-sys-31e8b6fd6077532c/out/bindings.rs:3:333067
[INFO] [stdout]   |
[INFO] [stdout] 3 | ...t_eq ! (unsafe { & (* (:: core :: ptr :: null :: < ble_hci_ev_le_subev_enh_conn_complete > ())) . supervision_timeout as * const _ as ...
[INFO] [stdout]   |                     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]   |
[INFO] [stdout]   = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]   = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]   = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0507]: cannot move out of `self.reports` which is behind a shared reference
[INFO] [stdout]  --> /opt/rustwide/target/debug/build/apache-nimble-sys-31e8b6fd6077532c/out/bindings.rs:3:335593
[INFO] [stdout]   |
[INFO] [stdout] 3 | ...e (Debug)] pub struct ble_hci_ev_le_subev_direct_adv_rpt { pub subev_code : u8 , pub num_reports : u8 , pub reports : __IncompleteArrayField < dir_adv_report > , ...
[INFO] [stdout]   |       ----- in this derive macro expansion                                                                 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ move occurs because `self.reports` has type `__IncompleteArrayField<dir_adv_report>`, which does not implement the `Copy` trait
[INFO] [stdout]   |
[INFO] [stdout]   = note: `#[derive(Debug)]` triggers a move because taking references to the fields of a packed struct is undefined behaviour
[INFO] [stdout]   = note: this error originates in the derive macro `Debug` (in Nightly builds, run with -Z macro-backtrace for more info)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]  --> /opt/rustwide/target/debug/build/apache-nimble-sys-31e8b6fd6077532c/out/bindings.rs:3:338088
[INFO] [stdout]   |
[INFO] [stdout] 3 | ...sert_eq ! (unsafe { & (* (:: core :: ptr :: null :: < ble_hci_ev_le_subev_phy_update_complete > ())) . conn_handle as * const _ as usi...
[INFO] [stdout]   |                        ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]   |
[INFO] [stdout]   = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]   = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]   = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0507]: cannot move out of `self.data` which is behind a shared reference
[INFO] [stdout]  --> /opt/rustwide/target/debug/build/apache-nimble-sys-31e8b6fd6077532c/out/bindings.rs:3:339208
[INFO] [stdout]   |
[INFO] [stdout] 3 | ...e (Debug)] pub struct ext_adv_report { pub evt_type : u16 , pub addr_type : u8 , pub addr : [u8 ; 6usize] , pub pri_phy : u8 , pub sec_phy : u8 , pub sid : u8 , pub tx_power : i8 , pub rssi : i8 , pub periodic_itvl : u16 , pub dir_addr_type : u8 , pub dir_addr : [u8 ; 6usize] , pub data_len : u8 , pub data : __IncompleteArrayField < u8 > , ...
[INFO] [stdout]   |       ----- in this derive macro expansion                                                                                                                                                                                                                                                                    ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ move occurs because `self.data` has type `__IncompleteArrayField<u8>`, which does not implement the `Copy` trait
[INFO] [stdout]   |
[INFO] [stdout]   = note: `#[derive(Debug)]` triggers a move because taking references to the fields of a packed struct is undefined behaviour
[INFO] [stdout]   = note: this error originates in the derive macro `Debug` (in Nightly builds, run with -Z macro-backtrace for more info)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]  --> /opt/rustwide/target/debug/build/apache-nimble-sys-31e8b6fd6077532c/out/bindings.rs:3:339597
[INFO] [stdout]   |
[INFO] [stdout] 3 | ...report))) ; assert_eq ! (unsafe { & (* (:: core :: ptr :: null :: < ext_adv_report > ())) . evt_type as * const _ as usize } , 0usize ...
[INFO] [stdout]   |                                      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]   |
[INFO] [stdout]   = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]   = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]   = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]  --> /opt/rustwide/target/debug/build/apache-nimble-sys-31e8b6fd6077532c/out/bindings.rs:3:341341
[INFO] [stdout]   |
[INFO] [stdout] 3 | ...ssi))) ; assert_eq ! (unsafe { & (* (:: core :: ptr :: null :: < ext_adv_report > ())) . periodic_itvl as * const _ as usize } , 14usi...
[INFO] [stdout]   |                                   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]   |
[INFO] [stdout]   = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]   = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]   = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0507]: cannot move out of `self.reports` which is behind a shared reference
[INFO] [stdout]  --> /opt/rustwide/target/debug/build/apache-nimble-sys-31e8b6fd6077532c/out/bindings.rs:3:342574
[INFO] [stdout]   |
[INFO] [stdout] 3 | ...e (Debug)] pub struct ble_hci_ev_le_subev_ext_adv_rpt { pub subev_code : u8 , pub num_reports : u8 , pub reports : __IncompleteArrayField < ext_adv_report > , ...
[INFO] [stdout]   |       ----- in this derive macro expansion                                                              ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ move occurs because `self.reports` has type `__IncompleteArrayField<ext_adv_report>`, which does not implement the `Copy` trait
[INFO] [stdout]   |
[INFO] [stdout]   = note: `#[derive(Debug)]` triggers a move because taking references to the fields of a packed struct is undefined behaviour
[INFO] [stdout]   = note: this error originates in the derive macro `Debug` (in Nightly builds, run with -Z macro-backtrace for more info)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]  --> /opt/rustwide/target/debug/build/apache-nimble-sys-31e8b6fd6077532c/out/bindings.rs:3:345165
[INFO] [stdout]   |
[INFO] [stdout] 3 | ...rt_eq ! (unsafe { & (* (:: core :: ptr :: null :: < ble_hci_ev_le_subev_periodic_adv_sync_estab > ())) . sync_handle as * const _ as u...
[INFO] [stdout]   |                      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]   |
[INFO] [stdout]   = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]   = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]   = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]  --> /opt/rustwide/target/debug/build/apache-nimble-sys-31e8b6fd6077532c/out/bindings.rs:3:346561
[INFO] [stdout]   |
[INFO] [stdout] 3 | ...ert_eq ! (unsafe { & (* (:: core :: ptr :: null :: < ble_hci_ev_le_subev_periodic_adv_sync_estab > ())) . interval as * const _ as usi...
[INFO] [stdout]   |                       ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]   |
[INFO] [stdout]   = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]   = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]   = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0507]: cannot move out of `self.data` which is behind a shared reference
[INFO] [stdout]  --> /opt/rustwide/target/debug/build/apache-nimble-sys-31e8b6fd6077532c/out/bindings.rs:3:347327
[INFO] [stdout]   |
[INFO] [stdout] 3 | ...e (Debug)] pub struct ble_hci_ev_le_subev_periodic_adv_rpt { pub subev_code : u8 , pub sync_handle : u16 , pub tx_power : i8 , pub rssi : i8 , pub cte_type : u8 , pub data_status : u8 , pub data_len : u8 , pub data : __IncompleteArrayField < u8 > , ...
[INFO] [stdout]   |       ----- in this derive macro expansion                                                                                                                                                                       ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ move occurs because `self.data` has type `__IncompleteArrayField<u8>`, which does not implement the `Copy` trait
[INFO] [stdout]   |
[INFO] [stdout]   = note: `#[derive(Debug)]` triggers a move because taking references to the fields of a packed struct is undefined behaviour
[INFO] [stdout]   = note: this error originates in the derive macro `Debug` (in Nightly builds, run with -Z macro-backtrace for more info)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]  --> /opt/rustwide/target/debug/build/apache-nimble-sys-31e8b6fd6077532c/out/bindings.rs:3:348094
[INFO] [stdout]   |
[INFO] [stdout] 3 | ...ssert_eq ! (unsafe { & (* (:: core :: ptr :: null :: < ble_hci_ev_le_subev_periodic_adv_rpt > ())) . sync_handle as * const _ as usize...
[INFO] [stdout]   |                         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]   |
[INFO] [stdout]   = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]   = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]   = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]  --> /opt/rustwide/target/debug/build/apache-nimble-sys-31e8b6fd6077532c/out/bindings.rs:3:350849
[INFO] [stdout]   |
[INFO] [stdout] 3 | ...rt_eq ! (unsafe { & (* (:: core :: ptr :: null :: < ble_hci_ev_le_subev_periodic_adv_sync_lost > ())) . sync_handle as * const _ as us...
[INFO] [stdout]   |                      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]   |
[INFO] [stdout]   = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]   = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]   = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]  --> /opt/rustwide/target/debug/build/apache-nimble-sys-31e8b6fd6077532c/out/bindings.rs:3:353404
[INFO] [stdout]   |
[INFO] [stdout] 3 | ...sert_eq ! (unsafe { & (* (:: core :: ptr :: null :: < ble_hci_ev_le_subev_adv_set_terminated > ())) . conn_handle as * const _ as usiz...
[INFO] [stdout]   |                        ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]   |
[INFO] [stdout]   = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]   = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]   = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]  --> /opt/rustwide/target/debug/build/apache-nimble-sys-31e8b6fd6077532c/out/bindings.rs:3:356474
[INFO] [stdout]   |
[INFO] [stdout] 3 | ... assert_eq ! (unsafe { & (* (:: core :: ptr :: null :: < ble_hci_ev_le_subev_chan_sel_alg > ())) . conn_handle as * const _ as usize }...
[INFO] [stdout]   |                           ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]   |
[INFO] [stdout]   = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]   = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]   = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]  --> /opt/rustwide/target/debug/build/apache-nimble-sys-31e8b6fd6077532c/out/bindings.rs:3:358393
[INFO] [stdout]   |
[INFO] [stdout] 3 | ..._eq ! (unsafe { & (* (:: core :: ptr :: null :: < ble_hci_ev_le_subev_periodic_adv_sync_transfer > ())) . conn_handle as * const _ as ...
[INFO] [stdout]   |                    ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]   |
[INFO] [stdout]   = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]   = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]   = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]  --> /opt/rustwide/target/debug/build/apache-nimble-sys-31e8b6fd6077532c/out/bindings.rs:3:358684
[INFO] [stdout]   |
[INFO] [stdout] 3 | ..._eq ! (unsafe { & (* (:: core :: ptr :: null :: < ble_hci_ev_le_subev_periodic_adv_sync_transfer > ())) . service_data as * const _ as...
[INFO] [stdout]   |                    ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]   |
[INFO] [stdout]   = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]   = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]   = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]  --> /opt/rustwide/target/debug/build/apache-nimble-sys-31e8b6fd6077532c/out/bindings.rs:3:358977
[INFO] [stdout]   |
[INFO] [stdout] 3 | ..._eq ! (unsafe { & (* (:: core :: ptr :: null :: < ble_hci_ev_le_subev_periodic_adv_sync_transfer > ())) . sync_handle as * const _ as ...
[INFO] [stdout]   |                    ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]   |
[INFO] [stdout]   = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]   = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]   = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]  --> /opt/rustwide/target/debug/build/apache-nimble-sys-31e8b6fd6077532c/out/bindings.rs:3:360404
[INFO] [stdout]   |
[INFO] [stdout] 3 | ...rt_eq ! (unsafe { & (* (:: core :: ptr :: null :: < ble_hci_ev_le_subev_periodic_adv_sync_transfer > ())) . interval as * const _ as u...
[INFO] [stdout]   |                      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]   |
[INFO] [stdout]   = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]   = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]   = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]  --> /opt/rustwide/target/debug/build/apache-nimble-sys-31e8b6fd6077532c/out/bindings.rs:3:362453
[INFO] [stdout]   |
[INFO] [stdout] 3 | ...assert_eq ! (unsafe { & (* (:: core :: ptr :: null :: < ble_hci_ev_le_subev_cis_established > ())) . cis_handle as * const _ as usize ...
[INFO] [stdout]   |                          ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]   |
[INFO] [stdout]   = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]   = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]   = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]  --> /opt/rustwide/target/debug/build/apache-nimble-sys-31e8b6fd6077532c/out/bindings.rs:3:365668
[INFO] [stdout]   |
[INFO] [stdout] 3 | ...ssert_eq ! (unsafe { & (* (:: core :: ptr :: null :: < ble_hci_ev_le_subev_cis_established > ())) . max_pdu_mtos as * const _ as usize...
[INFO] [stdout]   |                         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]   |
[INFO] [stdout]   = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]   = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]   = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]  --> /opt/rustwide/target/debug/build/apache-nimble-sys-31e8b6fd6077532c/out/bindings.rs:3:365940
[INFO] [stdout]   |
[INFO] [stdout] 3 | ...ssert_eq ! (unsafe { & (* (:: core :: ptr :: null :: < ble_hci_ev_le_subev_cis_established > ())) . max_pdu_stom as * const _ as usize...
[INFO] [stdout]   |                         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]   |
[INFO] [stdout]   = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]   = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]   = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]  --> /opt/rustwide/target/debug/build/apache-nimble-sys-31e8b6fd6077532c/out/bindings.rs:3:366212
[INFO] [stdout]   |
[INFO] [stdout] 3 | ...ssert_eq ! (unsafe { & (* (:: core :: ptr :: null :: < ble_hci_ev_le_subev_cis_established > ())) . iso_interval as * const _ as usize...
[INFO] [stdout]   |                         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]   |
[INFO] [stdout]   = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]   = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]   = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]  --> /opt/rustwide/target/debug/build/apache-nimble-sys-31e8b6fd6077532c/out/bindings.rs:3:367359
[INFO] [stdout]   |
[INFO] [stdout] 3 | ...; assert_eq ! (unsafe { & (* (:: core :: ptr :: null :: < ble_hci_ev_le_subev_cis_request > ())) . conn_handle as * const _ as usize }...
[INFO] [stdout]   |                            ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]   |
[INFO] [stdout]   = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]   = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]   = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]  --> /opt/rustwide/target/debug/build/apache-nimble-sys-31e8b6fd6077532c/out/bindings.rs:3:367620
[INFO] [stdout]   |
[INFO] [stdout] 3 | ...; assert_eq ! (unsafe { & (* (:: core :: ptr :: null :: < ble_hci_ev_le_subev_cis_request > ())) . cis_handle as * const _ as usize } ...
[INFO] [stdout]   |                            ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]   |
[INFO] [stdout]   = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]   = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]   = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0507]: cannot move out of `self.bis` which is behind a shared reference
[INFO] [stdout]  --> /opt/rustwide/target/debug/build/apache-nimble-sys-31e8b6fd6077532c/out/bindings.rs:3:368725
[INFO] [stdout]   |
[INFO] [stdout] 3 | ...e (Debug)] pub struct ble_hci_ev_le_subev_big_complete { pub subev_code : u8 , pub status : u8 , pub big_handle : u8 , pub big_sync_delay : [u8 ; 3usize] , pub transport_latency : [u8 ; 3usize] , pub phy : u8 , pub nse : u8 , pub bn : u8 , pub pto : u8 , pub irc : u8 , pub max_pdu : u16 , pub iso_interval : u16 , pub bis_cnt : u8 , pub bis : __IncompleteArrayField < u16 > , ...
[INFO] [stdout]   |       ----- in this derive macro expansion                                                                                                                                                                                                                                                                                                       ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ move occurs because `self.bis` has type `__IncompleteArrayField<u16>`, which does not implement the `Copy` trait
[INFO] [stdout]   |
[INFO] [stdout]   = note: `#[derive(Debug)]` triggers a move because taking references to the fields of a packed struct is undefined behaviour
[INFO] [stdout]   = note: this error originates in the derive macro `Debug` (in Nightly builds, run with -Z macro-backtrace for more info)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]  --> /opt/rustwide/target/debug/build/apache-nimble-sys-31e8b6fd6077532c/out/bindings.rs:3:371760
[INFO] [stdout]   |
[INFO] [stdout] 3 | ... ; assert_eq ! (unsafe { & (* (:: core :: ptr :: null :: < ble_hci_ev_le_subev_big_complete > ())) . max_pdu as * const _ as usize } ,...
[INFO] [stdout]   |                             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]   |
[INFO] [stdout]   = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]   = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]   = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]  --> /opt/rustwide/target/debug/build/apache-nimble-sys-31e8b6fd6077532c/out/bindings.rs:3:372016
[INFO] [stdout]   |
[INFO] [stdout] 3 | ... assert_eq ! (unsafe { & (* (:: core :: ptr :: null :: < ble_hci_ev_le_subev_big_complete > ())) . iso_interval as * const _ as usize ...
[INFO] [stdout]   |                           ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]   |
[INFO] [stdout]   = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]   = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]   = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]  --> /opt/rustwide/target/debug/build/apache-nimble-sys-31e8b6fd6077532c/out/bindings.rs:3:372538
[INFO] [stdout]   |
[INFO] [stdout] 3 | ...)) ; assert_eq ! (unsafe { & (* (:: core :: ptr :: null :: < ble_hci_ev_le_subev_big_complete > ())) . bis as * const _ as usize } , 1...
[INFO] [stdout]   |                               ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]   |
[INFO] [stdout]   = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]   = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]   = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0507]: cannot move out of `self.bis_handles` which is behind a shared reference
[INFO] [stdout]  --> /opt/rustwide/target/debug/build/apache-nimble-sys-31e8b6fd6077532c/out/bindings.rs:3:374560
[INFO] [stdout]   |
[INFO] [stdout] 3 | ...e (Debug)] pub struct ble_hci_ev_le_subev_big_sync_established { pub subev_code : u8 , pub status : u8 , pub big_handle : u8 , pub transport_latency : [u8 ; 3usize] , pub nse : u8 , pub bn : u8 , pub pto : u8 , pub irc : u8 , pub max_pdu : u16 , pub iso_interval : u16 , pub bis_cnt : u8 , pub bis_handles : __IncompleteArrayField < u16 > , ...
[INFO] [stdout]   |       ----- in this derive macro expansion                                                                                                                                                                                                                                                           ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ move occurs because `self.bis_handles` has type `__IncompleteArrayField<u16>`, which does not implement the `Copy` trait
[INFO] [stdout]   |
[INFO] [stdout]   = note: `#[derive(Debug)]` triggers a move because taking references to the fields of a packed struct is undefined behaviour
[INFO] [stdout]   = note: this error originates in the derive macro `Debug` (in Nightly builds, run with -Z macro-backtrace for more info)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]  --> /opt/rustwide/target/debug/build/apache-nimble-sys-31e8b6fd6077532c/out/bindings.rs:3:377251
[INFO] [stdout]   |
[INFO] [stdout] 3 | ...ssert_eq ! (unsafe { & (* (:: core :: ptr :: null :: < ble_hci_ev_le_subev_big_sync_established > ())) . max_pdu as * const _ as usize...
[INFO] [stdout]   |                         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]   |
[INFO] [stdout]   = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]   = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]   = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]  --> /opt/rustwide/target/debug/build/apache-nimble-sys-31e8b6fd6077532c/out/bindings.rs:3:377523
[INFO] [stdout]   |
[INFO] [stdout] 3 | ...ert_eq ! (unsafe { & (* (:: core :: ptr :: null :: < ble_hci_ev_le_subev_big_sync_established > ())) . iso_interval as * const _ as us...
[INFO] [stdout]   |                       ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]   |
[INFO] [stdout]   = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]   = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]   = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]  --> /opt/rustwide/target/debug/build/apache-nimble-sys-31e8b6fd6077532c/out/bindings.rs:3:378077
[INFO] [stdout]   |
[INFO] [stdout] 3 | ...ert_eq ! (unsafe { & (* (:: core :: ptr :: null :: < ble_hci_ev_le_subev_big_sync_established > ())) . bis_handles as * const _ as usi...
[INFO] [stdout]   |                       ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]   |
[INFO] [stdout]   = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]   = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]   = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]  --> /opt/rustwide/target/debug/build/apache-nimble-sys-31e8b6fd6077532c/out/bindings.rs:3:380883
[INFO] [stdout]   |
[INFO] [stdout] 3 | ...ssert_eq ! (unsafe { & (* (:: core :: ptr :: null :: < ble_hci_ev_le_subev_peer_sca_complete > ())) . conn_handle as * const _ as usiz...
[INFO] [stdout]   |                         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]   |
[INFO] [stdout]   = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]   = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]   = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]  --> /opt/rustwide/target/debug/build/apache-nimble-sys-31e8b6fd6077532c/out/bindings.rs:3:382520
[INFO] [stdout]   |
[INFO] [stdout] 3 | ...sert_eq ! (unsafe { & (* (:: core :: ptr :: null :: < ble_hci_ev_le_subev_biginfo_adv_report > ())) . sync_handle as * const _ as usiz...
[INFO] [stdout]   |                        ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]   |
[INFO] [stdout]   = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]   = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]   = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]  --> /opt/rustwide/target/debug/build/apache-nimble-sys-31e8b6fd6077532c/out/bindings.rs:3:383321
[INFO] [stdout]   |
[INFO] [stdout] 3 | ...sert_eq ! (unsafe { & (* (:: core :: ptr :: null :: < ble_hci_ev_le_subev_biginfo_adv_report > ())) . iso_interval as * const _ as usi...
[INFO] [stdout]   |                        ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]   |
[INFO] [stdout]   = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]   = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]   = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]  --> /opt/rustwide/target/debug/build/apache-nimble-sys-31e8b6fd6077532c/out/bindings.rs:3:384373
[INFO] [stdout]   |
[INFO] [stdout] 3 | ...assert_eq ! (unsafe { & (* (:: core :: ptr :: null :: < ble_hci_ev_le_subev_biginfo_adv_report > ())) . max_pdu as * const _ as usize ...
[INFO] [stdout]   |                          ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]   |
[INFO] [stdout]   = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]   = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]   = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]  --> /opt/rustwide/target/debug/build/apache-nimble-sys-31e8b6fd6077532c/out/bindings.rs:3:384919
[INFO] [stdout]   |
[INFO] [stdout] 3 | ...assert_eq ! (unsafe { & (* (:: core :: ptr :: null :: < ble_hci_ev_le_subev_biginfo_adv_report > ())) . max_sdu as * const _ as usize ...
[INFO] [stdout]   |                          ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]   |
[INFO] [stdout]   = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]   = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]   = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: aborting due to 220 previous errors; 6 warnings emitted
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] Some errors have detailed explanations: E0507, E0793.
[INFO] [stdout] 
[INFO] [stdout] For more information about an error, try `rustc --explain E0507`.
[INFO] [stdout] 
[INFO] [stderr] The following warnings were emitted during compilation:
[INFO] [stderr] 
[INFO] [stderr] warning: apache-nimble-sys@0.0.1: Compiler version doesn't include clang or GCC: "cc" "--version"
[INFO] [stderr] 
[INFO] [stderr] error: could not compile `apache-nimble-sys` (lib test) due to 221 previous errors; 6 warnings emitted
[INFO] running `Command { std: "docker" "inspect" "da4bd2c83464f286d81844822263e857b1bb3c11d0dfa6f65646767fd925d190", kill_on_drop: false }`
[INFO] running `Command { std: "docker" "rm" "-f" "da4bd2c83464f286d81844822263e857b1bb3c11d0dfa6f65646767fd925d190", kill_on_drop: false }`
[INFO] [stdout] da4bd2c83464f286d81844822263e857b1bb3c11d0dfa6f65646767fd925d190
