This PR implements the rust-struct-bindgen.

It contains three crates:

• rust-struct-bindgen-impl: The core implementation, which accepts a btf::types::Btf and yields a TokenStream represented rust source code.
• rust-struct-bindgen-proc-macro: A wrapper for the impl, provides convenience for using rust-struct-bindgen in rust sources.
• rust-struct-bindgen-cli: Another wrapper. Which accepts btf file path from command line argument and prints the output source code to stdout or writes to file

The generating stragety:

• For every struct, enum, int, float, array, ptr, rust-struct-bindgen will generate a represented type named btf_type_XX, where XX is the btf type id of the corresponding type for them. And the corresponding serializing and deserializing function will also be generated.
• Serializing functions always have signature like fn (&T) -> Result<Vec<u8>, String>where T is the generated rust type. The function name will always be deserialize_btf_type_XX, where XX is the type id. This function will be in the inner_impl module.
• Deserializing functions have signature like fn (&[u8]) -> Result<T, String>, T is also the generated rust type. The function name will always be serialize_btf_type_XX, where XX is the type id. This function will be in the inner_impl module.
• struct and enums will have a type alias pointing to the btf_type_XX type. The alias will be its original name. And deserializing function and serializing function will also be associated functions of the alias type.
• The alias of struct and enums will be put at the top level module. All other type definitions and (de)serializing functions will be put under a module named inner_impl; All things are pub.

e.g, for a btf int with sz 64bits and unsigned encoding and typeid 1, rust-struct-bindgen will generate the following code:

    #[allow(unused)]
    #[allow(non_camel_case_types)]
    pub type btf_type_1 = u64;
    #[allow(unused)]
    pub fn deserialize_btf_type_1(b: &[u8]) -> Result<btf_type_1, String> {
        if b.len() != 8 {
            return Err("Expected a slice with 8 bytes".to_string());
        }
        Ok(u64::from_ne_bytes(b.try_into().unwrap()))
    }
    #[allow(unused)]
    pub fn serialize_btf_type_1(v: &btf_type_1) -> Result<Vec<u8>, String> {
        Ok(v.to_ne_bytes().to_vec())
    }

Note: the code above has been formatted by rust-fmt. The directly generated code is terribly ugly, with no line-breaks, and only spaces.

Is your feature request related to a problem? Please describe.

Use this tool for generating rust binding for wasm-bpf program.

Describe the solution you'd like

Modify the rust example and document in wasm-bpf to use this tool.