Generate flexible array members the c99 way instead of the GNU way

serge-sans-paille · serge-sans-paille · commit 4697c73a595c · 2024-08-17T09:07:04.000+02:00
There a re three ways to express flexible array members:

1. char fam[0];
2. char fam[1];
3. char fam[];

3. is the only standard way (in c99, but supported in c++ as an
extension), the other two are GNU syntax (still supported in clang
though).

To avoid regression, let's generate the GNU syntax by default, while leaving it possible to
use 3. through struct.c99_flexible_array_members

Cython only supports the 1. mode.
diff --git a/src/bindgen/cdecl.rs b/src/bindgen/cdecl.rs
@@ -22,6 +22,7 @@ enum CDeclarator {
         is_ref: bool,
     },
     Array(String),
+    FlexibleArray(),
     Func {
         args: Vec<(Option<String>, CDecl)>,
         layout: Layout,
@@ -167,6 +168,10 @@ impl CDecl {
                 self.declarators.push(CDeclarator::Array(len));
                 self.build_type(t, is_const, config);
             }
+            Type::FlexibleArray(ref t) => {
+                self.declarators.push(CDeclarator::FlexibleArray());
+                self.build_type(t, is_const, config);
+            }
             Type::FuncPtr {
                 ref ret,
                 ref args,
@@ -254,7 +259,7 @@ impl CDecl {
                         }
                     }
                 }
-                CDeclarator::Array(..) => {
+                CDeclarator::Array(..) | CDeclarator::FlexibleArray() => {
                     if next_is_pointer {
                         out.write("(");
                     }
@@ -286,10 +291,26 @@ impl CDecl {
                     if last_was_pointer {
                         out.write(")");
                     }
+
                     write!(out, "[{}]", constant);
 
                     last_was_pointer = false;
                 }
+                CDeclarator::FlexibleArray() => {
+                    if last_was_pointer {
+                        out.write(")");
+                    }
+
+                    if config.structure.c99_flexible_array_members
+                        && config.language != Language::Cython
+                    {
+                        write!(out, "[]");
+                    } else {
+                        write!(out, "[0]");
+                    }
+
+                    last_was_pointer = false;
+                }
                 CDeclarator::Func {
                     ref args,
                     ref layout,
diff --git a/src/bindgen/config.rs b/src/bindgen/config.rs
@@ -499,6 +499,8 @@ pub struct StructConfig {
     pub deprecated: Option<String>,
     /// The way to annotation this function as #[deprecated] with notes
     pub deprecated_with_note: Option<String>,
+    /// The way we represent flexible array members, either GNU style or c99 style
+    pub c99_flexible_array_members: bool,
 }
 
 impl StructConfig {
diff --git a/src/bindgen/ir/structure.rs b/src/bindgen/ir/structure.rs
@@ -71,7 +71,7 @@ impl Struct {
             layout_config.ensure_safe_to_represent(&align)?;
         }
 
-        let fields = match item.fields {
+        let mut fields = match item.fields {
             syn::Fields::Unit => Vec::new(),
             syn::Fields::Named(ref fields) => fields
                 .named
@@ -97,6 +97,20 @@ impl Struct {
             }
         };
 
+        match fields.last() {
+            Some(Field {
+                name: _,
+                ty: Type::Array(ty, sz),
+                cfg: _,
+                annotations: _,
+                documentation: _,
+            }) if sz.as_str() == "0" => {
+                let last_index = fields.len() - 1;
+                fields[last_index].ty = Type::FlexibleArray(ty.clone());
+            }
+            _ => (),
+        }
+
         let has_tag_field = false;
         let is_enum_variant_body = false;
 
diff --git a/src/bindgen/ir/ty.rs b/src/bindgen/ir/ty.rs
@@ -317,6 +317,7 @@ pub enum Type {
     Path(GenericPath),
     Primitive(PrimitiveType),
     Array(Box<Type>, ConstExpr),
+    FlexibleArray(Box<Type>),
     FuncPtr {
         ret: Box<Type>,
         args: Vec<(Option<String>, Type)>,
@@ -583,7 +584,9 @@ impl Type {
 
     fn visit_types(&mut self, mut visitor: impl FnMut(&mut Type)) {
         match *self {
-            Type::Array(ref mut ty, ..) | Type::Ptr { ref mut ty, .. } => visitor(ty),
+            Type::Array(ref mut ty, ..)
+            | Type::FlexibleArray(ref mut ty)
+            | Type::Ptr { ref mut ty, .. } => visitor(ty),
             Type::Path(ref mut path) => {
                 for generic in path.generics_mut() {
                     match *generic {
@@ -617,7 +620,7 @@ impl Type {
                 Type::Primitive(..) => {
                     return None;
                 }
-                Type::Array(..) => {
+                Type::Array(..) | Type::FlexibleArray(..) => {
                     return None;
                 }
                 Type::FuncPtr { .. } => {
@@ -664,6 +667,7 @@ impl Type {
                 Box::new(ty.specialize(mappings)),
                 constant.specialize(mappings),
             ),
+            Type::FlexibleArray(ref ty) => Type::FlexibleArray(Box::new(ty.specialize(mappings))),
             Type::FuncPtr {
                 ref ret,
                 ref args,
@@ -721,7 +725,7 @@ impl Type {
                 }
             }
             Type::Primitive(_) => {}
-            Type::Array(ref ty, _) => {
+            Type::Array(ref ty, _) | Type::FlexibleArray(ref ty) => {
                 ty.add_dependencies_ignoring_generics(generic_params, library, out);
             }
             Type::FuncPtr {
@@ -757,7 +761,7 @@ impl Type {
                 }
             }
             Type::Primitive(_) => {}
-            Type::Array(ref ty, _) => {
+            Type::Array(ref ty, _) | Type::FlexibleArray(ref ty) => {
                 ty.add_monomorphs(library, out);
             }
             Type::FuncPtr {
@@ -784,6 +788,9 @@ impl Type {
                 ty.rename_for_config(config, generic_params);
                 len.rename_for_config(config);
             }
+            Type::FlexibleArray(ref mut ty) => {
+                ty.rename_for_config(config, generic_params);
+            }
             Type::FuncPtr {
                 ref mut ret,
                 ref mut args,
@@ -806,7 +813,7 @@ impl Type {
                 generic_path.resolve_declaration_types(resolver);
             }
             Type::Primitive(_) => {}
-            Type::Array(ref mut ty, _) => {
+            Type::Array(ref mut ty, _) | Type::FlexibleArray(ref mut ty) => {
                 ty.resolve_declaration_types(resolver);
             }
             Type::FuncPtr {
@@ -843,7 +850,7 @@ impl Type {
                 }
             }
             Type::Primitive(_) => {}
-            Type::Array(ref mut ty, _) => {
+            Type::Array(ref mut ty, _) | Type::FlexibleArray(ref mut ty) => {
                 ty.mangle_paths(monomorphs);
             }
             Type::FuncPtr {
@@ -866,6 +873,7 @@ impl Type {
             Type::Path(..) => true,
             Type::Primitive(ref p) => p.can_cmp_order(),
             Type::Array(..) => false,
+            Type::FlexibleArray(..) => false,
             Type::FuncPtr { .. } => false,
         }
     }
@@ -876,6 +884,7 @@ impl Type {
             Type::Path(..) => true,
             Type::Primitive(ref p) => p.can_cmp_eq(),
             Type::Array(..) => false,
+            Type::FlexibleArray(..) => false,
             Type::FuncPtr { .. } => true,
         }
     }
diff --git a/src/bindgen/mangle.rs b/src/bindgen/mangle.rs
@@ -128,7 +128,7 @@ impl<'a> Mangler<'a> {
                     self.push(Separator::EndFn);
                 }
             }
-            Type::Array(..) => {
+            Type::Array(..) | Type::FlexibleArray(..) => {
                 unimplemented!(
                     "Unable to mangle generic parameter {:?} for '{}'",
                     ty,
diff --git a/tests/expectations/struct.c b/tests/expectations/struct.c
@@ -25,4 +25,15 @@ typedef struct {
   float y;
 } TupleNamed;
 
-void root(Opaque *a, Normal b, NormalWithZST c, TupleRenamed d, TupleNamed e);
+typedef struct {
+  int32_t x;
+  int16_t y[0];
+  int8_t z[];
+} WithFlexibleArrayMember;
+
+void root(Opaque *a,
+          Normal b,
+          NormalWithZST c,
+          TupleRenamed d,
+          TupleNamed e,
+          WithFlexibleArrayMember f);
diff --git a/tests/expectations/struct.compat.c b/tests/expectations/struct.compat.c
@@ -25,11 +25,22 @@ typedef struct {
   float y;
 } TupleNamed;
 
+typedef struct {
+  int32_t x;
+  int16_t y[0];
+  int8_t z[];
+} WithFlexibleArrayMember;
+
 #ifdef __cplusplus
 extern "C" {
 #endif // __cplusplus
 
-void root(Opaque *a, Normal b, NormalWithZST c, TupleRenamed d, TupleNamed e);
+void root(Opaque *a,
+          Normal b,
+          NormalWithZST c,
+          TupleRenamed d,
+          TupleNamed e,
+          WithFlexibleArrayMember f);
 
 #ifdef __cplusplus
 }  // extern "C"
diff --git a/tests/expectations/struct.cpp b/tests/expectations/struct.cpp
@@ -26,8 +26,19 @@ struct TupleNamed {
   float y;
 };
 
+struct WithFlexibleArrayMember {
+  int32_t x;
+  int16_t y[0];
+  int8_t z[];
+};
+
 extern "C" {
 
-void root(Opaque *a, Normal b, NormalWithZST c, TupleRenamed d, TupleNamed e);
+void root(Opaque *a,
+          Normal b,
+          NormalWithZST c,
+          TupleRenamed d,
+          TupleNamed e,
+          WithFlexibleArrayMember f);
 
 }  // extern "C"
diff --git a/tests/expectations/struct.pyx b/tests/expectations/struct.pyx
@@ -25,4 +25,14 @@ cdef extern from *:
     int32_t x;
     float y;
 
-  void root(Opaque *a, Normal b, NormalWithZST c, TupleRenamed d, TupleNamed e);
+  ctypedef struct WithFlexibleArrayMember:
+    int32_t x;
+    int16_t y[0];
+    int8_t z[0];
+
+  void root(Opaque *a,
+            Normal b,
+            NormalWithZST c,
+            TupleRenamed d,
+            TupleNamed e,
+            WithFlexibleArrayMember f);
diff --git a/tests/expectations/struct_both.c b/tests/expectations/struct_both.c
@@ -25,8 +25,15 @@ typedef struct TupleNamed {
   float y;
 } TupleNamed;
 
+typedef struct WithFlexibleArrayMember {
+  int32_t x;
+  int16_t y[0];
+  int8_t z[];
+} WithFlexibleArrayMember;
+
 void root(struct Opaque *a,
           struct Normal b,
           struct NormalWithZST c,
           struct TupleRenamed d,
-          struct TupleNamed e);
+          struct TupleNamed e,
+          struct WithFlexibleArrayMember f);
diff --git a/tests/expectations/struct_both.compat.c b/tests/expectations/struct_both.compat.c
@@ -25,6 +25,12 @@ typedef struct TupleNamed {
   float y;
 } TupleNamed;
 
+typedef struct WithFlexibleArrayMember {
+  int32_t x;
+  int16_t y[0];
+  int8_t z[];
+} WithFlexibleArrayMember;
+
 #ifdef __cplusplus
 extern "C" {
 #endif // __cplusplus
@@ -33,7 +39,8 @@ void root(struct Opaque *a,
           struct Normal b,
           struct NormalWithZST c,
           struct TupleRenamed d,
-          struct TupleNamed e);
+          struct TupleNamed e,
+          struct WithFlexibleArrayMember f);
 
 #ifdef __cplusplus
 }  // extern "C"
diff --git a/tests/expectations/struct_tag.c b/tests/expectations/struct_tag.c
@@ -25,8 +25,15 @@ struct TupleNamed {
   float y;
 };
 
+struct WithFlexibleArrayMember {
+  int32_t x;
+  int16_t y[0];
+  int8_t z[];
+};
+
 void root(struct Opaque *a,
           struct Normal b,
           struct NormalWithZST c,
           struct TupleRenamed d,
-          struct TupleNamed e);
+          struct TupleNamed e,
+          struct WithFlexibleArrayMember f);
diff --git a/tests/expectations/struct_tag.compat.c b/tests/expectations/struct_tag.compat.c
@@ -25,6 +25,12 @@ struct TupleNamed {
   float y;
 };
 
+struct WithFlexibleArrayMember {
+  int32_t x;
+  int16_t y[0];
+  int8_t z[];
+};
+
 #ifdef __cplusplus
 extern "C" {
 #endif // __cplusplus
@@ -33,7 +39,8 @@ void root(struct Opaque *a,
           struct Normal b,
           struct NormalWithZST c,
           struct TupleRenamed d,
-          struct TupleNamed e);
+          struct TupleNamed e,
+          struct WithFlexibleArrayMember f);
 
 #ifdef __cplusplus
 }  // extern "C"
diff --git a/tests/expectations/struct_tag.pyx b/tests/expectations/struct_tag.pyx
@@ -25,4 +25,14 @@ cdef extern from *:
     int32_t x;
     float y;
 
-  void root(Opaque *a, Normal b, NormalWithZST c, TupleRenamed d, TupleNamed e);
+  cdef struct WithFlexibleArrayMember:
+    int32_t x;
+    int16_t y[0];
+    int8_t z[0];
+
+  void root(Opaque *a,
+            Normal b,
+            NormalWithZST c,
+            TupleRenamed d,
+            TupleNamed e,
+            WithFlexibleArrayMember f);
diff --git a/tests/rust/struct.rs b/tests/rust/struct.rs
@@ -28,11 +28,19 @@ struct TupleRenamed(i32, f32);
 #[repr(C)]
 struct TupleNamed(i32, f32);
 
+#[repr(C)]
+struct WithFlexibleArrayMember {
+    x: i32,
+    y: [i16; 0],
+    z: [i8; 0],
+}
+
 #[no_mangle]
 pub extern "C" fn root(
     a: *mut Opaque,
     b: Normal,
     c: NormalWithZST,
     d: TupleRenamed,
-    e: TupleNamed
+    e: TupleNamed,
+    f: WithFlexibleArrayMember,
 ) { }

Original file line number	Diff line number	Diff line change
`@@ -499,6 +499,8 @@ pub struct StructConfig {`
`499`	`499`	`pub deprecated: Option<String>,`
`500`	`500`	`/// The way to annotation this function as #[deprecated] with notes`
`501`	`501`	`pub deprecated_with_note: Option<String>,`
	`502`	`+ /// The way we represent flexible array members, either GNU style or c99 style`
	`503`	`+ pub c99_flexible_array_members: bool,`
`502`	`504`	`}`
`503`	`505`
`504`	`506`	`impl StructConfig {`
Original file line number	Diff line number	Diff line change
`@@ -317,6 +317,7 @@ pub enum Type {`
`317`	`317`	`Path(GenericPath),`
`318`	`318`	`Primitive(PrimitiveType),`
`319`	`319`	`Array(Box<Type>, ConstExpr),`
	`320`	`+ FlexibleArray(Box<Type>),`
`320`	`321`	`FuncPtr {`
`321`	`322`	`ret: Box<Type>,`
`322`	`323`	`args: Vec<(Option<String>, Type)>,`
`@@ -583,7 +584,9 @@ impl Type {`
`583`	`584`
`584`	`585`	`fn visit_types(&mut self, mut visitor: impl FnMut(&mut Type)) {`
`585`	`586`	`match *self {`
`586`		`- Type::Array(ref mut ty, ..) \| Type::Ptr { ref mut ty, .. } => visitor(ty),`
	`587`	`+ Type::Array(ref mut ty, ..)`
	`588`	`+ \| Type::FlexibleArray(ref mut ty)`
	`589`	`+ \| Type::Ptr { ref mut ty, .. } => visitor(ty),`
`587`	`590`	`Type::Path(ref mut path) => {`
`588`	`591`	`for generic in path.generics_mut() {`
`589`	`592`	`match *generic {`
`@@ -617,7 +620,7 @@ impl Type {`
`617`	`620`	`Type::Primitive(..) => {`
`618`	`621`	`return None;`
`619`	`622`	`}`
`620`		`- Type::Array(..) => {`
	`623`	`+ Type::Array(..) \| Type::FlexibleArray(..) => {`
`621`	`624`	`return None;`
`622`	`625`	`}`
`623`	`626`	`Type::FuncPtr { .. } => {`
`@@ -664,6 +667,7 @@ impl Type {`
`664`	`667`	`Box::new(ty.specialize(mappings)),`
`665`	`668`	`constant.specialize(mappings),`
`666`	`669`	`),`
	`670`	`+ Type::FlexibleArray(ref ty) => Type::FlexibleArray(Box::new(ty.specialize(mappings))),`
`667`	`671`	`Type::FuncPtr {`
`668`	`672`	`ref ret,`
`669`	`673`	`ref args,`
`@@ -721,7 +725,7 @@ impl Type {`
`721`	`725`	`}`
`722`	`726`	`}`
`723`	`727`	`Type::Primitive(_) => {}`
`724`		`- Type::Array(ref ty, _) => {`
	`728`	`+ Type::Array(ref ty, _) \| Type::FlexibleArray(ref ty) => {`
`725`	`729`	`ty.add_dependencies_ignoring_generics(generic_params, library, out);`
`726`	`730`	`}`
`727`	`731`	`Type::FuncPtr {`
`@@ -757,7 +761,7 @@ impl Type {`
`757`	`761`	`}`
`758`	`762`	`}`
`759`	`763`	`Type::Primitive(_) => {}`
`760`		`- Type::Array(ref ty, _) => {`
	`764`	`+ Type::Array(ref ty, _) \| Type::FlexibleArray(ref ty) => {`
`761`	`765`	`ty.add_monomorphs(library, out);`
`762`	`766`	`}`
`763`	`767`	`Type::FuncPtr {`
`@@ -784,6 +788,9 @@ impl Type {`
`784`	`788`	`ty.rename_for_config(config, generic_params);`
`785`	`789`	`len.rename_for_config(config);`
`786`	`790`	`}`
	`791`	`+ Type::FlexibleArray(ref mut ty) => {`
	`792`	`+ ty.rename_for_config(config, generic_params);`
	`793`	`+ }`
`787`	`794`	`Type::FuncPtr {`
`788`	`795`	`ref mut ret,`
`789`	`796`	`ref mut args,`
`@@ -806,7 +813,7 @@ impl Type {`
`806`	`813`	`generic_path.resolve_declaration_types(resolver);`
`807`	`814`	`}`
`808`	`815`	`Type::Primitive(_) => {}`
`809`		`- Type::Array(ref mut ty, _) => {`
	`816`	`+ Type::Array(ref mut ty, _) \| Type::FlexibleArray(ref mut ty) => {`
`810`	`817`	`ty.resolve_declaration_types(resolver);`
`811`	`818`	`}`
`812`	`819`	`Type::FuncPtr {`
`@@ -843,7 +850,7 @@ impl Type {`
`843`	`850`	`}`
`844`	`851`	`}`
`845`	`852`	`Type::Primitive(_) => {}`
`846`		`- Type::Array(ref mut ty, _) => {`
	`853`	`+ Type::Array(ref mut ty, _) \| Type::FlexibleArray(ref mut ty) => {`
`847`	`854`	`ty.mangle_paths(monomorphs);`
`848`	`855`	`}`
`849`	`856`	`Type::FuncPtr {`
`@@ -866,6 +873,7 @@ impl Type {`
`866`	`873`	`Type::Path(..) => true,`
`867`	`874`	`Type::Primitive(ref p) => p.can_cmp_order(),`
`868`	`875`	`Type::Array(..) => false,`
	`876`	`+ Type::FlexibleArray(..) => false,`
`869`	`877`	`Type::FuncPtr { .. } => false,`
`870`	`878`	`}`
`871`	`879`	`}`
`@@ -876,6 +884,7 @@ impl Type {`
`876`	`884`	`Type::Path(..) => true,`
`877`	`885`	`Type::Primitive(ref p) => p.can_cmp_eq(),`
`878`	`886`	`Type::Array(..) => false,`
	`887`	`+ Type::FlexibleArray(..) => false,`
`879`	`888`	`Type::FuncPtr { .. } => true,`
`880`	`889`	`}`
`881`	`890`	`}`
Original file line number	Diff line number	Diff line change
`@@ -128,7 +128,7 @@ impl<'a> Mangler<'a> {`
`128`	`128`	`self.push(Separator::EndFn);`
`129`	`129`	`}`
`130`	`130`	`}`
`131`		`- Type::Array(..) => {`
	`131`	`+ Type::Array(..) \| Type::FlexibleArray(..) => {`
`132`	`132`	`unimplemented!(`
`133`	`133`	`"Unable to mangle generic parameter {:?} for '{}'",`
`134`	`134`	`ty,`