Re: [PATCH dwarves] pahole: --unions shouldn't bypass struct-only options

[Aditya Dutt <duttaditya18@gmail.com>]

On Mon, Aug 31, 2026 at 06:35:16PM -0300, Arnaldo Carvalho de Melo wrote:
> Please split this into multiple patches, so that we can cherry pick
> independent patches when we have some issue with one of the patches in
> the series.

I'll split this change to 3 patches.
1. Fixing only the segfault by adding the guard at the top of
print_packable_info. Contains the Fixes tag.
2. --with_flexible_array and --with_embedded_flexible_array guard if !struct.
3. In the case of unions, don't ignore struct-only filters.

Is this good, so that whatever is needed can be picked up?

> I can imagine looking for an union with bit holes:
>
> union x86_pmu_config {
> 	struct {
> 		u64                event:8;            /*     0: 0  8 */
> 		u64                umask:8;            /*     0: 8  8 */
> 		u64                usr:1;              /*     0:16  8 */
> 		u64                os:1;               /*     0:17  8 */
> 		u64                edge:1;             /*     0:18  8 */
> 		u64                pc:1;               /*     0:19  8 */
> 		u64                interrupt:1;        /*     0:20  8 */
> 		u64                __reserved1:1;      /*     0:21  8 */
> 		u64                en:1;               /*     0:22  8 */
> 		u64                inv:1;              /*     0:23  8 */
> 		u64                cmask:8;            /*     0:24  8 */
> 		u64                event2:4;           /*     0:32  8 */
> 		u64                __reserved2:4;      /*     0:36  8 */
> 		u64                go:1;               /*     0:40  8 */
> 		u64                ho:1;               /*     0:41  8 */
> 	} bits;                                        /*     0     8 */
> 	u64                        value;              /*     0     8 */
> };
>
> The sum of that bitfield is 42 bits, so we have a "padding"/hole of 22
> bits in that union, can't see quickly a use fase for this right now, but
> maybe someone can have this corner case need?

You can already get that using 'pahole -a -A' (both flags are needed).
For example:

	$ cat /tmp/a.c
	typedef unsigned long long u64;
	union u_hole {
		struct {
			u64 a:8;
			u64 b:8;
			u64 c:1;
		} bits;
		u64 value;
	};
	union u_hole u;
	$ gcc -c -g /tmp/a.c -o /tmp/a.o
	$ pahole -a -A /tmp/a.o
	struct {
		u64                        a:8;                  /*     0: 0  8 */
		u64                        b:8;                  /*     0: 8  8 */
		u64                        c:1;                  /*     0:16  8 */

		/* size: 8, cachelines: 1, members: 3 */
		/* bit_padding: 47 bits */
		/* last cacheline: 8 bytes */
	};
	union u_hole {
		struct {
			u64                a:8;                /*     0: 0  8 */
			u64                b:8;                /*     0: 8  8 */
			u64                c:1;                /*     0:16  8 */
		} bits;                                        /*     0     8 */
		u64                        value;              /*     0     8 */
	};

The padding is for the anonymous struct and not the union itself.
Does it make sense for '--unions' to show the results for the anonymous
structs inside a union?

Maybe a '--recursive' modifier is better? Which looks inside
structs/unions and unions when applying the filters, so that the outer
struct/union returned if a filter applies to any inner struct/union.

> > --with_flexible_array and --with_embedded_flexible_array were missing from the
> > struct only list, so add them too.
>
> Well spotted, please put this in a separate patch, with the
> corresponding fix.

Same thing here, a union cannot have a flexible array directly but a
union may have a struct inside containing a flexible array. Maybe a
'--recursive' modifier makes sense? And optionally, you can specify the
depth to which we search '--recursive=2' etc.

-- 

Thanks,
Aditya Dutt