rust: bindgen: upgrade to 0.65.1

GNU C                  5.1              gcc --version

Clang/LLVM (optional)  11.0.0           clang --version

Rust (optional)        1.71.1           rustc --version

bindgen (optional)     0.56.0           bindgen --version

bindgen (optional)     0.65.1           bindgen --version

GNU make               3.82             make --version

bash                   4.2              bash --version

binutils               2.25             ld -v

Install it via (note that this will download and build the tool from source)::

	cargo install --locked --version $(scripts/min-tool-version.sh bindgen) bindgen

	cargo install --locked --version $(scripts/min-tool-version.sh bindgen) bindgen-cli

``bindgen`` needs to find a suitable ``libclang`` in order to work. If it is

not found (or a different ``libclang`` than the one found should be used),

	$(BINDGEN) $< $(bindgen_target_flags) \

		--use-core --with-derive-default --ctypes-prefix core::ffi --no-layout-tests \

		--no-debug '.*' \

		--size_t-is-usize -o $@ -- $(bindgen_c_flags_final) -DMODULE \

		-o $@ -- $(bindgen_c_flags_final) -DMODULE \

		$(bindgen_target_cflags) $(bindgen_target_extra)

$(obj)/bindings/bindings_generated.rs: private bindgen_target_flags = \

# given it is `libclang`; but for consistency, future Clang changes and/or

# a potential future GCC backend for `bindgen`, we disable it too.

$(obj)/bindings/bindings_helpers_generated.rs: private bindgen_target_flags = \

    --blacklist-type '.*' --whitelist-var '' \

    --whitelist-function 'rust_helper_.*'

    --blocklist-type '.*' --allowlist-var '' \

    --allowlist-function 'rust_helper_.*'

$(obj)/bindings/bindings_helpers_generated.rs: private bindgen_target_cflags = \

    -I$(objtree)/$(obj) -Wno-missing-prototypes -Wno-missing-declarations

$(obj)/bindings/bindings_helpers_generated.rs: private bindgen_target_extra = ; \

EXPORT_SYMBOL_GPL(rust_helper_put_task_struct);

/*

 * We use `bindgen`'s `--size_t-is-usize` option to bind the C `size_t` type

 * as the Rust `usize` type, so we can use it in contexts where Rust

 * expects a `usize` like slice (array) indices. `usize` is defined to be

 * the same as C's `uintptr_t` type (can hold any pointer) but not

 * necessarily the same as `size_t` (can hold the size of any single

 * object). Most modern platforms use the same concrete integer type for

 * `bindgen` binds the C `size_t` type as the Rust `usize` type, so we can

 * use it in contexts where Rust expects a `usize` like slice (array) indices.

 * `usize` is defined to be the same as C's `uintptr_t` type (can hold any

 * pointer) but not necessarily the same as `size_t` (can hold the size of any

 * single object). Most modern platforms use the same concrete integer type for

 * both of them, but in case we find ourselves on a platform where

 * that's not true, fail early instead of risking ABI or

 * integer-overflow issues.

 *

 * If your platform fails this assertion, it means that you are in

 * danger of integer-overflow bugs (even if you attempt to remove

 * `--size_t-is-usize`). It may be easiest to change the kernel ABI on

 * danger of integer-overflow bugs (even if you attempt to add

 * `--no-size_t-is-usize`). It may be easiest to change the kernel ABI on

 * your platform such that `size_t` matches `uintptr_t` (i.e., to increase

 * `size_t`, because `uintptr_t` has to be at least as big as `size_t`).

 */

    pr_emerg!("{}\n", info);

    // SAFETY: FFI call.

    unsafe { bindings::BUG() };

    // Bindgen currently does not recognize `__noreturn` so `BUG` returns `()`

    // instead of `!`. See <https://github.com/rust-lang/rust-bindgen/issues/2094>.

    loop {}

}