mirror of
git://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git
synced 2026-04-07 23:19:12 +08:00
0652035a57
In theory, compilers should be able to work this out themselves so we can use a simpler version based on the swab() helpers. I have verified that this works on all supported compiler versions (gcc-4.9 and up, clang-10 and up). Looking at the object code produced by gcc-11, I found that the impact is mostly a change in inlining decisions that lead to slightly larger code. In other cases, this version produces explicit byte swaps in place of separate byte access, or comparing against pre-swapped constants. While the source code is clearly simpler, I have not seen an indication of the new version actually producing better code on Arm, so maybe we want to skip this after all. From what I can tell, gcc recognizes the byteswap pattern in the byteshift.h header and can turn it into explicit instructions, but it does not turn a __builtin_bswap32() back into individual bytes when that would result in better output, e.g. when storing a byte-reversed constant. Suggested-by: Linus Torvalds <torvalds@linux-foundation.org> Signed-off-by: Arnd Bergmann <arnd@arndb.de>
68 lines
1.4 KiB
C
68 lines
1.4 KiB
C
/* SPDX-License-Identifier: GPL-2.0 */
|
|
#ifndef _LINUX_UNALIGNED_LE_STRUCT_H
|
|
#define _LINUX_UNALIGNED_LE_STRUCT_H
|
|
|
|
#include <linux/unaligned/packed_struct.h>
|
|
|
|
static inline u16 get_unaligned_le16(const void *p)
|
|
{
|
|
return __get_unaligned_cpu16((const u8 *)p);
|
|
}
|
|
|
|
static inline u32 get_unaligned_le32(const void *p)
|
|
{
|
|
return __get_unaligned_cpu32((const u8 *)p);
|
|
}
|
|
|
|
static inline u64 get_unaligned_le64(const void *p)
|
|
{
|
|
return __get_unaligned_cpu64((const u8 *)p);
|
|
}
|
|
|
|
static inline void put_unaligned_le16(u16 val, void *p)
|
|
{
|
|
__put_unaligned_cpu16(val, p);
|
|
}
|
|
|
|
static inline void put_unaligned_le32(u32 val, void *p)
|
|
{
|
|
__put_unaligned_cpu32(val, p);
|
|
}
|
|
|
|
static inline void put_unaligned_le64(u64 val, void *p)
|
|
{
|
|
__put_unaligned_cpu64(val, p);
|
|
}
|
|
|
|
static inline u16 get_unaligned_be16(const void *p)
|
|
{
|
|
return swab16(__get_unaligned_cpu16((const u8 *)p));
|
|
}
|
|
|
|
static inline u32 get_unaligned_be32(const void *p)
|
|
{
|
|
return swab32(__get_unaligned_cpu32((const u8 *)p));
|
|
}
|
|
|
|
static inline u64 get_unaligned_be64(const void *p)
|
|
{
|
|
return swab64(__get_unaligned_cpu64((const u8 *)p));
|
|
}
|
|
|
|
static inline void put_unaligned_be16(u16 val, void *p)
|
|
{
|
|
__put_unaligned_cpu16(swab16(val), p);
|
|
}
|
|
|
|
static inline void put_unaligned_be32(u32 val, void *p)
|
|
{
|
|
__put_unaligned_cpu32(swab32(val), p);
|
|
}
|
|
|
|
static inline void put_unaligned_be64(u64 val, void *p)
|
|
{
|
|
__put_unaligned_cpu64(swab64(val), p);
|
|
}
|
|
|
|
#endif /* _LINUX_UNALIGNED_LE_STRUCT_H */
|