Add --flexarray-dst option

This option uses Rust DST types to model C structures with flexible
array members.

For example, if you declare:
```c
struct record {
    int len;
    float values[];
}
```
this means it's a C structure with a well-defined prefix, but a tail of
`values` which depends on how much memory we've allocated for it.

We can model this in Rust with:
```rust
struct record {
    len: c_int,
    values: [f32],
}
```
which means more or less the same thing - there's a type which has a
known prefix, but its suffix is not directly known.

Author: jsgf

bindgen-cli/options.rs

@@ -406,6 +406,9 @@ struct BindgenCommand {
     /// Set path for temporary files generated by fallback for clang macro parsing.
     #[arg(long)]
     clang_macro_fallback_build_dir: Option<PathBuf>,
+    /// Use DSTs to represent structures with flexible array members.
+    #[arg(long)]
+    flexarray_dst: bool,
     /// Derive custom traits on any kind of type. The CUSTOM value must be of the shape REGEX=DERIVE where DERIVE is a coma-separated list of derive macros.
     #[arg(long, value_name = "CUSTOM", value_parser = parse_custom_derive)]
     with_derive_custom: Vec<(Vec<String>, String)>,
@@ -562,6 +565,7 @@ where
         wrap_unsafe_ops,
         clang_macro_fallback,
         clang_macro_fallback_build_dir,
+        flexarray_dst,
         with_derive_custom,
         with_derive_custom_struct,
         with_derive_custom_enum,
@@ -1039,6 +1043,10 @@ where
         builder = builder.clang_macro_fallback_build_dir(path);
     }
 
+    if flexarray_dst {
+        builder = builder.flexarray_dst(true);
+    }
+
     #[derive(Debug)]
     struct CustomDeriveCallback {
         derives: Vec<String>,

bindgen/codegen/mod.rs

@@ -1454,10 +1454,13 @@ impl<'a> FieldCodegen<'a> for FieldData {
             wrap_union_field_if_needed(ctx, struct_layout, ty, result)
         } else if let Some(item) = field_ty.is_incomplete_array(ctx) {
             result.saw_incomplete_array();
+            struct_layout.saw_flexible_array();
 
             let inner = item.to_rust_ty_or_opaque(ctx, &());
 
-            if ctx.options().enable_cxx_namespaces {
+            if ctx.options().flexarray_dst {
+                syn::parse_quote! { FAM }
+            } else if ctx.options().enable_cxx_namespaces {
                 syn::parse_quote! { root::__IncompleteArrayField<#inner> }
             } else {
                 syn::parse_quote! { __IncompleteArrayField<#inner> }
@@ -2208,20 +2211,60 @@ impl CodeGenerator for CompInfo {
             });
         }
 
-        let generics = if !generic_param_names.is_empty() {
-            let generic_param_names = generic_param_names.clone();
-            quote! {
-                < #( #generic_param_names ),* >
+        let (flex_array_generic, flex_inner_ty) = if ctx.options().flexarray_dst
+        {
+            match self.flex_array_member(ctx) {
+                Some(ty) => {
+                    let inner = ty.to_rust_ty_or_opaque(ctx, &());
+                    (
+                        Some(quote! { FAM: ?Sized = [ #inner; 0 ] }),
+                        Some(quote! { #inner }),
+                    )
+                }
+                None => (None, None),
             }
         } else {
-            quote! {}
+            (None, None)
         };
 
+        // Generics, including the flexible array member.
+        //
+        // generics - generic parameters for the struct declaration
+        // impl_generics_labels - generic parameters for `impl<...>`
+        // impl_generics_params - generic parameters for `impl structname<...>`
+        //
+        // `impl` blocks are for non-FAM related impls like Default, etc
+        let (generics, impl_generics_labels, impl_generics_params) =
+            if !generic_param_names.is_empty() || flex_array_generic.is_some() {
+                let (flex_sized, flex_fam) = match flex_inner_ty.as_ref() {
+                    None => (None, None),
+                    Some(ty) => (
+                        Some(quote! { [ #ty; 0 ] }),
+                        Some(quote! { FAM: ?Sized = [ #ty; 0 ] }),
+                    ),
+                };
+
+                (
+                    quote! {
+                        < #( #generic_param_names , )* #flex_fam >
+                    },
+                    quote! {
+                        < #( #generic_param_names , )* >
+                    },
+                    quote! {
+                        < #( #generic_param_names , )* #flex_sized >
+                    },
+                )
+            } else {
+                (quote! {}, quote! {}, quote! {})
+            };
+
         let mut attributes = vec![];
         let mut needs_clone_impl = false;
         let mut needs_default_impl = false;
         let mut needs_debug_impl = false;
         let mut needs_partialeq_impl = false;
+        let needs_flexarray_impl = flex_array_generic.is_some();
         if let Some(comment) = item.comment(ctx) {
             attributes.push(attributes::doc(comment));
         }
@@ -2525,17 +2568,112 @@ impl CodeGenerator for CompInfo {
         // NB: We can't use to_rust_ty here since for opaque types this tries to
         // use the specialization knowledge to generate a blob field.
         let ty_for_impl = quote! {
-            #canonical_ident #generics
+            #canonical_ident #impl_generics_params
         };
 
         if needs_clone_impl {
             result.push(quote! {
-                impl #generics Clone for #ty_for_impl {
+                impl #impl_generics_labels Clone for #ty_for_impl {
                     fn clone(&self) -> Self { *self }
                 }
             });
         }
 
+        if needs_flexarray_impl {
+            let prefix = ctx.trait_prefix();
+
+            let flex_array =
+                flex_inner_ty.as_ref().map(|ty| quote! { [ #ty ] });
+
+            let dst_ty_for_impl = quote! {
+                #canonical_ident < #( #generic_param_names , )* #flex_array >
+
+            };
+            let sized_ty_for_impl = quote! {
+                #canonical_ident < #( #generic_param_names , )* [ #flex_inner_ty; 0 ] >
+            };
+
+            let turbo_dst_ty = quote! {
+                #canonical_ident :: < #( #generic_param_names , )* [ #flex_inner_ty ] >
+            };
+
+            let layout = if ctx.options().rust_features().layout_for_ptr {
+                quote! {
+                    pub fn layout(len: usize) -> ::#prefix::alloc::Layout {
+                        // SAFETY: Null pointers are OK if we don't deref them
+                        unsafe {
+                            let p: *const Self = ::#prefix::ptr::from_raw_parts(::#prefix::ptr::null(), len);
+                            ::#prefix::alloc::Layout::for_value_raw(p)
+                        }
+                    }
+                }
+            } else {
+                quote!()
+            };
+
+            let (from_ptr_dst, from_ptr_sized) = if ctx
+                .options()
+                .rust_features()
+                .ptr_metadata
+            {
+                (
+                    quote! {
+                        /// Construct a DST for `#canonical_ident` from a thin
+                        /// pointer.
+                        ///
+                        /// SAFETY: the `len` must be <= the underlying storage.
+                        /// Note: returned lifetime is unbounded.
+                        pub unsafe fn from_ptr<'a>(ptr: *const #sized_ty_for_impl, len: usize) -> &'a Self {
+                            let ptr: *const Self = ::#prefix::ptr::from_raw_parts(ptr as *const (), len);
+                            &*ptr
+                        }
+
+                        /// Construct a mutable DST for `#canonical_ident` from
+                        /// a thin pointer. This is `MaybeUninit` to allow for
+                        /// initialization.
+                        ///
+                        /// SAFETY: the `len` must be <= the underlying storage.
+                        /// Note: returned lifetime is unbounded.
+                        pub unsafe fn from_ptr_mut<'a>(ptr: *mut #sized_ty_for_impl, len: usize) -> ::#prefix::mem::MaybeUninit<&'a mut Self> {
+                            let ptr: *mut Self = ::#prefix::ptr::from_raw_parts_mut(ptr as *mut (), len);
+                            ::#prefix::mem::MaybeUninit::new(&mut *ptr)
+                        }
+                    },
+                    quote! {
+                        /// Turn a sized reference for `#canonical_ident` into
+                        /// DST with the given `len`.
+                        ///
+                        /// SAFETY: the `len` must be <= the underlying storage.
+                        pub unsafe fn from_ref(&self, len: usize) -> & #dst_ty_for_impl {
+                            // SAFETY: caller guarantees `len` is good
+                            unsafe { #turbo_dst_ty :: from_ptr(self, len) }
+                        }
+
+                        /// Turn a mutable sized reference for
+                        /// `#canonical_ident` into DST with the given `len`.
+                        ///
+                        /// SAFETY: the `len` must be <= the underlying storage.
+                        pub unsafe fn from_ref_mut(&mut self, len: usize) -> &mut #dst_ty_for_impl {
+                            unsafe { #turbo_dst_ty :: from_ptr_mut(self, len).assume_init() }
+                        }
+                    },
+                )
+            } else {
+                (quote!(), quote!())
+            };
+
+            result.push(quote! {
+                impl #impl_generics_labels #dst_ty_for_impl {
+                    #layout
+                    #from_ptr_dst
+                }
+
+                impl #impl_generics_labels #sized_ty_for_impl {
+                    #from_ptr_sized
+                }
+            });
+        }
+
         if needs_default_impl {
             let prefix = ctx.trait_prefix();
             let body = if ctx.options().rust_features().maybe_uninit {
@@ -2560,7 +2698,7 @@ impl CodeGenerator for CompInfo {
             // non-zero padding bytes, especially when forwards/backwards compatibility is
             // involved.
             result.push(quote! {
-                impl #generics Default for #ty_for_impl {
+                impl #impl_generics_labels Default for #ty_for_impl {
                     fn default() -> Self {
                         #body
                     }
@@ -2579,7 +2717,7 @@ impl CodeGenerator for CompInfo {
             let prefix = ctx.trait_prefix();
 
             result.push(quote! {
-                impl #generics ::#prefix::fmt::Debug for #ty_for_impl {
+                impl #impl_generics_labels ::#prefix::fmt::Debug for #ty_for_impl {
                     #impl_
                 }
             });
@@ -2603,7 +2741,7 @@ impl CodeGenerator for CompInfo {
 
                 let prefix = ctx.trait_prefix();
                 result.push(quote! {
-                    impl #generics ::#prefix::cmp::PartialEq for #ty_for_impl #partialeq_bounds {
+                    impl #impl_generics_labels ::#prefix::cmp::PartialEq for #ty_for_impl #partialeq_bounds {
                         #impl_
                     }
                 });
@@ -2612,7 +2750,7 @@ impl CodeGenerator for CompInfo {
 
         if !methods.is_empty() {
             result.push(quote! {
-                impl #generics #ty_for_impl {
+                impl #impl_generics_labels #ty_for_impl {
                     #( #methods )*
                 }
             });
@@ -5130,6 +5268,9 @@ pub(crate) mod utils {
         ctx: &BindgenContext,
         result: &mut Vec<proc_macro2::TokenStream>,
     ) {
+        if ctx.options().flexarray_dst {
+            return;
+        }
         let prefix = ctx.trait_prefix();
 
         // If the target supports `const fn`, declare eligible functions

bindgen/codegen/struct_layout.rs

@@ -28,6 +28,7 @@ pub(crate) struct StructLayoutTracker<'a> {
     max_field_align: usize,
     last_field_was_bitfield: bool,
     visibility: FieldVisibilityKind,
+    last_field_was_flexible_array: bool,
 }
 
 /// Returns a size aligned to a given value.
@@ -110,6 +111,7 @@ impl<'a> StructLayoutTracker<'a> {
             latest_field_layout: None,
             max_field_align: 0,
             last_field_was_bitfield: false,
+            last_field_was_flexible_array: false,
         }
     }
 
@@ -121,6 +123,10 @@ impl<'a> StructLayoutTracker<'a> {
         self.is_rust_union
     }
 
+    pub(crate) fn saw_flexible_array(&mut self) {
+        self.last_field_was_flexible_array = true;
+    }
+
     pub(crate) fn saw_vtable(&mut self) {
         debug!("saw vtable for {}", self.name);
 
@@ -295,6 +301,11 @@ impl<'a> StructLayoutTracker<'a> {
             return None;
         }
 
+        // Also doesn't make sense for structs with flexible array members
+        if self.last_field_was_flexible_array {
+            return None;
+        }
+
         if self.latest_offset == comp_layout.size {
             // This struct does not contain tail padding.
             return None;

bindgen/features.rs

@@ -96,6 +96,8 @@ macro_rules! define_rust_targets {
 define_rust_targets! {
     Nightly => {
         vectorcall_abi,
+        ptr_metadata: #81513,
+        layout_for_ptr: #69835,
     },
     Stable_1_77(77) => { offset_of: #106655 },
     Stable_1_73(73) => { thiscall_abi: #42202 },

bindgen/ir/comp.rs

@@ -825,6 +825,24 @@ impl CompFields {
             }
         }
     }
+
+    /// Return the flex array member for the struct/class, if any.
+    fn flex_array_member(&self, ctx: &BindgenContext) -> Option<TypeId> {
+        let fields = match self {
+            CompFields::Before(_) => panic!("raw fields"),
+            CompFields::After { fields, .. } => fields,
+            CompFields::Error => return None, // panic?
+        };
+
+        // XXX correct with padding on end?
+        match fields.last() {
+            None | Some(Field::Bitfields(..)) => None,
+            Some(Field::DataMember(FieldData { ty, .. })) => ctx
+                .resolve_type(*ty)
+                .is_incomplete_array(ctx)
+                .map(|item| item.expect_type_id(ctx)),
+        }
+    }
 }
 
 impl Trace for CompFields {
@@ -1122,6 +1140,14 @@ impl CompInfo {
         }
     }
 
+    /// Return the flex array member and its element type if any
+    pub(crate) fn flex_array_member(
+        &self,
+        ctx: &BindgenContext,
+    ) -> Option<TypeId> {
+        self.fields.flex_array_member(ctx)
+    }
+
     fn has_fields(&self) -> bool {
         match self.fields {
             CompFields::Error => false,

bindgen/options/mod.rs

@@ -1981,6 +1981,19 @@ options! {
         },
         as_args: "--wrap-unsafe-ops",
     },
+    /// Use DSTs to represent structures with flexible array members.
+    flexarray_dst: bool {
+        methods: {
+            /// Use DSTs to represent structures with flexible array members.
+            ///
+            /// This option is disabled by default.
+            pub fn flexarray_dst(mut self, doit: bool) -> Self {
+                self.options.flexarray_dst = doit;
+                self
+            }
+        },
+        as_args: "--flexarray-dst",
+    },
     /// Patterns for functions whose ABI should be overridden.
     abi_overrides: HashMap<Abi, RegexSet> {
         methods: {