archives/linux
1
0
Fork 0
mirror of https://github.com/torvalds/linux.git synced 2026-03-08 01:04:41 +01:00
Code Issues Projects Releases Packages Wiki Activity Actions

tools headers: Update the linux/unaligned.h copy with the kernel sources

Browse source 
To pick up the changes in:

  vdso: Switch get/put_unaligned() from packed struct to memcpy

As the code is dependent on __unqual_scalar_typeof, update also the tools
version of compiler_types.h to include this.

Signed-off-by: Ian Rogers <irogers@google.com>
Signed-off-by: Thomas Gleixner <tglx@kernel.org>
Link: https://patch.msgid.link/20251016205126.2882625-4-irogers@google.com
This commit is contained in:
Ian Rogers 2025-10-16 13:51:25 -07:00 • committed by Thomas Gleixner
parent a339671db6
commit 1d7cf255ee
2 changed files with 57 additions and 6 deletions
Download patch file Download diff file Expand all files Collapse all files

22
tools/include/linux/compiler_types.h
View file

@ -40,4 +40,26 @@
#define asm_goto_output(x...) asm goto(x)
#endif
/*
* __unqual_scalar_typeof(x) - Declare an unqualified scalar type, leaving
* non-scalar types unchanged.
*/
/*
* Prefer C11 _Generic for better compile-times and simpler code. Note: 'char'
* is not type-compatible with 'signed char', and we define a separate case.
*/
#define __scalar_type_to_expr_cases(type) \
unsigned type: (unsigned type)0, \
signed type: (signed type)0
#define __unqual_scalar_typeof(x) typeof( \
_Generic((x), \
char: (char)0, \
__scalar_type_to_expr_cases(char), \
__scalar_type_to_expr_cases(short), \
__scalar_type_to_expr_cases(int), \
__scalar_type_to_expr_cases(long), \
__scalar_type_to_expr_cases(long long), \
default: (x)))
#endif /* __LINUX_COMPILER_TYPES_H */

41
tools/include/vdso/unaligned.h
View file

@ -2,14 +2,43 @@
#ifndef __VDSO_UNALIGNED_H
#define __VDSO_UNALIGNED_H
#define __get_unaligned_t(type, ptr) ({ \
const struct { type x; } __packed * __get_pptr = (typeof(__get_pptr))(ptr); \
__get_pptr->x; \
#include <linux/compiler_types.h>
/**
* __get_unaligned_t - read an unaligned value from memory.
* @type: the type to load from the pointer.
* @ptr: the pointer to load from.
*
* Use memcpy to affect an unaligned type sized load avoiding undefined behavior
* from approaches like type punning that require -fno-strict-aliasing in order
* to be correct. As type may be const, use __unqual_scalar_typeof to map to a
* non-const type - you can't memcpy into a const type. The
* __get_unaligned_ctrl_type gives __unqual_scalar_typeof its required
* expression rather than type, a pointer is used to avoid warnings about mixing
* the use of 0 and NULL. The void* cast silences ubsan warnings.
*/
#define __get_unaligned_t(type, ptr) ({ \
type *__get_unaligned_ctrl_type __always_unused = NULL; \
__unqual_scalar_typeof(*__get_unaligned_ctrl_type) __get_unaligned_val; \
__builtin_memcpy(&__get_unaligned_val, (void *)(ptr), \
sizeof(__get_unaligned_val)); \
__get_unaligned_val; \
})
#define __put_unaligned_t(type, val, ptr) do { \
struct { type x; } __packed * __put_pptr = (typeof(__put_pptr))(ptr); \
__put_pptr->x = (val); \
/**
* __put_unaligned_t - write an unaligned value to memory.
* @type: the type of the value to store.
* @val: the value to store.
* @ptr: the pointer to store to.
*
* Use memcpy to affect an unaligned type sized store avoiding undefined
* behavior from approaches like type punning that require -fno-strict-aliasing
* in order to be correct. The void* cast silences ubsan warnings.
*/
#define __put_unaligned_t(type, val, ptr) do { \
type __put_unaligned_val = (val); \
__builtin_memcpy((void *)(ptr), &__put_unaligned_val, \
sizeof(__put_unaligned_val)); \
} while (0)
#endif /* __VDSO_UNALIGNED_H */