Commit a91c9872 authored by Adrian Hunter's avatar Adrian Hunter Committed by Namhyung Kim
Browse files

perf tools: Add get_unaligned_leNN() 



Add get_unaligned_le16(), get_unaligned_le32 and get_unaligned_le64, same
as include/asm-generic/unaligned.h. And add include/asm-generic/unaligned.h
to check-headers.sh bringing tools/include/asm-generic/unaligned.h up to
date so that the kernel and tools versions match.

Use diagnostic pragmas to ignore -Wpacked used by perf build.

Signed-off-by: default avatarAdrian Hunter <adrian.hunter@intel.com>
Reviewed-by: default avatarIan Rogers <irogers@google.com>
Link: https://lore.kernel.org/r/20231005190451.175568-2-adrian.hunter@intel.com
Link: https://lore.kernel.org/r/20231010142234.20061-1-adrian.hunter@intel.com


[ squashed check-header.sh addition ]
Signed-off-by: default avatarNamhyung Kim <namhyung@kernel.org>
parent a16afcc5

tools/include/asm-generic/unaligned.h

+139 −6
Original line number Diff line number Diff line 
/* SPDX-License-Identifier: GPL-2.0-or-later */

/* SPDX-License-Identifier: GPL-2.0 */

#ifndef __ASM_GENERIC_UNALIGNED_H

#define __ASM_GENERIC_UNALIGNED_H



/*

 * Copied from the kernel sources to tools/perf/:

 * This is the most generic implementation of unaligned accesses

 * and should work almost anywhere.

 */



#ifndef __TOOLS_LINUX_ASM_GENERIC_UNALIGNED_H

#define __TOOLS_LINUX_ASM_GENERIC_UNALIGNED_H

#pragma GCC diagnostic push

#pragma GCC diagnostic ignored "-Wpacked"



#define __get_unaligned_t(type, ptr) ({						\

	const struct { type x; } __packed *__pptr = (typeof(__pptr))(ptr);	\
@@ -19,5 +22,135 @@ 
#define get_unaligned(ptr)	__get_unaligned_t(typeof(*(ptr)), (ptr))

#define put_unaligned(val, ptr) __put_unaligned_t(typeof(*(ptr)), (val), (ptr))



#endif /* __TOOLS_LINUX_ASM_GENERIC_UNALIGNED_H */

static inline u16 get_unaligned_le16(const void *p)

{

	return le16_to_cpu(__get_unaligned_t(__le16, p));

}



static inline u32 get_unaligned_le32(const void *p)

{

	return le32_to_cpu(__get_unaligned_t(__le32, p));

}



static inline u64 get_unaligned_le64(const void *p)

{

	return le64_to_cpu(__get_unaligned_t(__le64, p));

}



static inline void put_unaligned_le16(u16 val, void *p)

{

	__put_unaligned_t(__le16, cpu_to_le16(val), p);

}



static inline void put_unaligned_le32(u32 val, void *p)

{

	__put_unaligned_t(__le32, cpu_to_le32(val), p);

}



static inline void put_unaligned_le64(u64 val, void *p)

{

	__put_unaligned_t(__le64, cpu_to_le64(val), p);

}



static inline u16 get_unaligned_be16(const void *p)

{

	return be16_to_cpu(__get_unaligned_t(__be16, p));

}



static inline u32 get_unaligned_be32(const void *p)

{

	return be32_to_cpu(__get_unaligned_t(__be32, p));

}



static inline u64 get_unaligned_be64(const void *p)

{

	return be64_to_cpu(__get_unaligned_t(__be64, p));

}



static inline void put_unaligned_be16(u16 val, void *p)

{

	__put_unaligned_t(__be16, cpu_to_be16(val), p);

}



static inline void put_unaligned_be32(u32 val, void *p)

{

	__put_unaligned_t(__be32, cpu_to_be32(val), p);

}



static inline void put_unaligned_be64(u64 val, void *p)

{

	__put_unaligned_t(__be64, cpu_to_be64(val), p);

}



static inline u32 __get_unaligned_be24(const u8 *p)

{

	return p[0] << 16 | p[1] << 8 | p[2];

}



static inline u32 get_unaligned_be24(const void *p)

{

	return __get_unaligned_be24(p);

}



static inline u32 __get_unaligned_le24(const u8 *p)

{

	return p[0] | p[1] << 8 | p[2] << 16;

}



static inline u32 get_unaligned_le24(const void *p)

{

	return __get_unaligned_le24(p);

}



static inline void __put_unaligned_be24(const u32 val, u8 *p)

{

	*p++ = val >> 16;

	*p++ = val >> 8;

	*p++ = val;

}



static inline void put_unaligned_be24(const u32 val, void *p)

{

	__put_unaligned_be24(val, p);

}



static inline void __put_unaligned_le24(const u32 val, u8 *p)

{

	*p++ = val;

	*p++ = val >> 8;

	*p++ = val >> 16;

}



static inline void put_unaligned_le24(const u32 val, void *p)

{

	__put_unaligned_le24(val, p);

}



static inline void __put_unaligned_be48(const u64 val, u8 *p)

{

	*p++ = val >> 40;

	*p++ = val >> 32;

	*p++ = val >> 24;

	*p++ = val >> 16;

	*p++ = val >> 8;

	*p++ = val;

}



static inline void put_unaligned_be48(const u64 val, void *p)

{

	__put_unaligned_be48(val, p);

}



static inline u64 __get_unaligned_be48(const u8 *p)

{

	return (u64)p[0] << 40 | (u64)p[1] << 32 | (u64)p[2] << 24 |

		p[3] << 16 | p[4] << 8 | p[5];

}



static inline u64 get_unaligned_be48(const void *p)

{

	return __get_unaligned_be48(p);

}

#pragma GCC diagnostic pop



#endif /* __ASM_GENERIC_UNALIGNED_H */

tools/perf/check-headers.sh

+1 −0
Original line number Diff line number Diff line
@@ -162,6 +162,7 @@ check arch/x86/lib/memcpy_64.S '-I "^EXPORT_SYMBOL" -I "^#include <asm/ex 
check arch/x86/lib/memset_64.S        '-I "^EXPORT_SYMBOL" -I "^#include <asm/export.h>" -I"^SYM_FUNC_START\(_LOCAL\)*(memset_\(erms\|orig\))"'

check arch/x86/include/asm/amd-ibs.h  '-I "^#include [<\"]\(asm/\)*msr-index.h"'

check arch/arm64/include/asm/cputype.h '-I "^#include [<\"]\(asm/\)*sysreg.h"'

check include/asm-generic/unaligned.h '-I "^#include <linux/unaligned/packed_struct.h>" -I "^#include <asm/byteorder.h>" -I "^#pragma GCC diagnostic"'

check include/uapi/asm-generic/mman.h '-I "^#include <\(uapi/\)*asm-generic/mman-common\(-tools\)*.h>"'

check include/uapi/linux/mman.h       '-I "^#include <\(uapi/\)*asm/mman.h>"'

check include/linux/build_bug.h       '-I "^#\(ifndef\|endif\)\( \/\/\)* static_assert$"'