Commit c3b9a398 authored by Kees Cook's avatar Kees Cook
Browse files

compiler.h: Explain how __is_constexpr() works 



The __is_constexpr() macro is dark magic. Shed some light on it with
a comment to explain how and why it works.

Acked-by: default avatarGustavo A. R. Silva <gustavoars@kernel.org>
Reviewed-by: default avatarJani Nikula <jani.nikula@intel.com>
Link: https://lore.kernel.org/r/20240301044428.work.411-kees@kernel.org


Signed-off-by: default avatarKees Cook <keescook@chromium.org>
parent bd1ebf24

include/linux/compiler.h

+39 −0
Original line number Diff line number Diff line
@@ -231,6 +231,45 @@ static inline void *offset_to_ptr(const int *off) 
 * This returns a constant expression while determining if an argument is

 * a constant expression, most importantly without evaluating the argument.

 * Glory to Martin Uecker <Martin.Uecker@med.uni-goettingen.de>

 *

 * Details:

 * - sizeof() return an integer constant expression, and does not evaluate

 *   the value of its operand; it only examines the type of its operand.

 * - The results of comparing two integer constant expressions is also

 *   an integer constant expression.

 * - The first literal "8" isn't important. It could be any literal value.

 * - The second literal "8" is to avoid warnings about unaligned pointers;

 *   this could otherwise just be "1".

 * - (long)(x) is used to avoid warnings about 64-bit types on 32-bit

 *   architectures.

 * - The C Standard defines "null pointer constant", "(void *)0", as

 *   distinct from other void pointers.

 * - If (x) is an integer constant expression, then the "* 0l" resolves

 *   it into an integer constant expression of value 0. Since it is cast to

 *   "void *", this makes the second operand a null pointer constant.

 * - If (x) is not an integer constant expression, then the second operand

 *   resolves to a void pointer (but not a null pointer constant: the value

 *   is not an integer constant 0).

 * - The conditional operator's third operand, "(int *)8", is an object

 *   pointer (to type "int").

 * - The behavior (including the return type) of the conditional operator

 *   ("operand1 ? operand2 : operand3") depends on the kind of expressions

 *   given for the second and third operands. This is the central mechanism

 *   of the macro:

 *   - When one operand is a null pointer constant (i.e. when x is an integer

 *     constant expression) and the other is an object pointer (i.e. our

 *     third operand), the conditional operator returns the type of the

 *     object pointer operand (i.e. "int *). Here, within the sizeof(), we

 *     would then get:

 *       sizeof(*((int *)(...))  == sizeof(int)  == 4

 *   - When one operand is a void pointer (i.e. when x is not an integer

 *     constant expression) and the other is an object pointer (i.e. our

 *     third operand), the conditional operator returns a "void *" type.

 *     Here, within the sizeof(), we would then get:

 *       sizeof(*((void *)(...)) == sizeof(void) == 1

 * - The equality comparison to "sizeof(int)" therefore depends on (x):

 *     sizeof(int) == sizeof(int)     (x) was a constant expression

 *     sizeof(int) != sizeof(void)    (x) was not a constant expression

 */

#define __is_constexpr(x) \

	(sizeof(int) == sizeof(*(8 ? ((void *)((long)(x) * 0l)) : (int *)8)))