Re: [PATCH v3 4/5] string: Add [C]QChar_of() and QVoid_of()

[sashiko-bot@kernel.org]

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>
>  
> +/**
> + * 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.

-- 
Sashiko AI review · https://sashiko.dev/#/patchset/cover.1794323750.git.alx@kernel.org?part=4