Message-ID: <sashiko-outbox-207285@kernel.org>
From: sashiko-bot@kernel.org
Subject: Re: [PATCH v3 4/5] string: Add [C]QChar_of() and QVoid_of()
Reply-To: sashiko-reviews@lists.linux.dev
To: "Alejandro Colomar" <alx@kernel.org>
Cc: devicetree@vger.kernel.org, linux-gpio@vger.kernel.org, robh@kernel.org, conor+dt@kernel.org
In-Reply-To: <415453a31ebf1aed3b41da1a28913f5cbe58f175.1794323750.git.alx@kernel.org>
References: <cover.1794323750.git.alx@kernel.org>
 <415453a31ebf1aed3b41da1a28913f5cbe58f175.1794323750.git.alx@kernel.org>
Content-Type: text/plain; charset=utf-8
Content-Transfer-Encoding: quoted-printable
Date: Tue, 10 Nov 2026 15:45:13 +0000
Precedence: list

Thank you for your contribution! Sashiko AI review found 2 potential
issues to consider:
- [High] string: void pointer subscript in QVoid_of() breaks Clang
  builds
- [Medium] string: QChar_of() fails to compile when pointee has
  qualifiers other than Q
--

commit cea37634307d89ede7b6ca6128f006d50a90391c
Author: Alejandro Colomar <alx@kernel.org>

string: Add [C]QChar_of() and QVoid_of()

This commit introduces the QVoid_of(), QChar_of(), and CQChar_of() helper
macros in include/linux/string.h to support qualifier-generic string macros.

> diff --git a/include/linux/string.h b/include/linux/string.h
> index 3a70ba9ed3021..cb096e9eb9835 100644
> --- a/include/linux/string.h
> +++ b/include/linux/string.h
> @@ -14,6 +14,36 @@
>  #include <linux/stdarg.h>
>  #include <uapi/linux/string.h>
> =20
> +/**
> + * QVoid_of - qualified void of
> + *
> + * @p: Pointer to test for qualifiers
> + *
> + * This macro produces the type name 'void',
> + * qualified with any qualifiers present in the element of @p.
> + */
> +#define QVoid_of(p)       typeof((__QVoidptr_of(p)){0}[0])
> +#define __QVoidptr_of(p)  typeof(1?(p):(void*){0})

[Severity: High]
Does applying the array subscript [0] to a void pointer in QVoid_of()
break Clang builds?

__QVoidptr_of(p) produces a pointer to (qualified) void.  Because array
subscripting requires a pointer to a complete object type, Clang rejects
(__QVoidptr_of(p)){0}[0] even inside typeof() with an incomplete type
error, and GCC emits a -Wpointer-arith warning when pointer arithmetic
warnings are enabled.  Using unary * instead of [0], such as
typeof(*(__QVoidptr_of(p)){0}), avoids both issues.

> +
> +/**
> + * QChar_of - qualified char of
> + *
> + * @Q: Qualifier to test.
> + * @p: Pointer to test for the @Q qualifier
> + *
> + * This macro produces the type name 'char',
> + * @Q-qualified iff the input pointer points to a @Q-qualified element.
> + */
> +#define QChar_of(Q, p)  typeof                                        \
> +(                                                                     \
> +	_Generic((QVoid_of(p) *){0},                                  \
> +		Q void *:  (Q char){0},                               \
> +		void *:    (  char){0}                                \
> +	)                                                             \
> +)

[Severity: Medium]
Can QChar_of() fail to compile when the pointed-to type of p carries a
qualifier other than Q?

QVoid_of(p) preserves all qualifiers on the target of p, but the _Generic
selection only matches exact Q void * and unqualified void *.  Passing a
volatile char * or const volatile char * to CQChar_of(p) produces a
volatile void * or const volatile void * controlling expression, which
matches neither association and fails at compile time.  Matching against
Q QVoid_of(p) *: (Q char){0} and default: (char){0} would test specifically
for Q regardless of other qualifiers.

--=20
Sashiko AI review =C2=B7 https://sashiko.dev/#/patchset/cover.1794323750.gi=
t.alx@kernel.org?part=3D4