From: "H. Peter Anvin" <hpa@zytor.com>
To: Sam Ravnborg <sam@ravnborg.org>,
linux-kernel@vger.kernel.org, linux-kbuild@vger.kernel.org,
linux-arch@vger.kernel.org
Cc: Andy Lutomirski <luto@amacapital.net>,
Andrew Morton <akpm@linux-foundation.org>,
Ingo Molnar <mingo@kernel.org>,
Thomas Gleixner <tglx@linutronix.de>,
"H. Peter Anvin" <hpa@zytor.com>
Subject: [PATCH RFC 01/10] tools: Remove double-underscore symbols from user space byteshift functions
Date: Tue, 10 Jun 2014 16:13:05 -0700 [thread overview]
Message-ID: <1402441994-16780-2-git-send-email-hpa@zytor.com> (raw)
In-Reply-To: <1402441994-16780-1-git-send-email-hpa@zytor.com>
We should not use double-underscore (or underscore-capital) symbols in
arbitrary user space code, and these include files are specifically
used for user space compilation. Furthermore, the indirection is
completely unnecessary in this case.
Also, reorder the littleendian put macros to allow the compiler to
generate better code on some architectures (stores in sequence.)
Signed-off-by: H. Peter Anvin <hpa@zytor.com>
---
tools/include/tools/be_byteshift.h | 62 ++++++++++++++------------------------
tools/include/tools/le_byteshift.h | 62 ++++++++++++++------------------------
2 files changed, 44 insertions(+), 80 deletions(-)
diff --git a/tools/include/tools/be_byteshift.h b/tools/include/tools/be_byteshift.h
index 84c17d836578..9850c7df2667 100644
--- a/tools/include/tools/be_byteshift.h
+++ b/tools/include/tools/be_byteshift.h
@@ -3,68 +3,50 @@
#include <stdint.h>
-static inline uint16_t __get_unaligned_be16(const uint8_t *p)
+static inline uint16_t get_unaligned_be16(const void *_p)
{
- return p[0] << 8 | p[1];
-}
+ const uint8_t *p = _p;
-static inline uint32_t __get_unaligned_be32(const uint8_t *p)
-{
- return p[0] << 24 | p[1] << 16 | p[2] << 8 | p[3];
+ return p[0] << 8 | p[1];
}
-static inline uint64_t __get_unaligned_be64(const uint8_t *p)
+static inline uint32_t get_unaligned_be32(const void *_p)
{
- return (uint64_t)__get_unaligned_be32(p) << 32 |
- __get_unaligned_be32(p + 4);
-}
+ const uint8_t *p = _p;
-static inline void __put_unaligned_be16(uint16_t val, uint8_t *p)
-{
- *p++ = val >> 8;
- *p++ = val;
+ return p[0] << 24 | p[1] << 16 | p[2] << 8 | p[3];
}
-static inline void __put_unaligned_be32(uint32_t val, uint8_t *p)
+static inline uint64_t get_unaligned_be64(const void *_p)
{
- __put_unaligned_be16(val >> 16, p);
- __put_unaligned_be16(val, p + 2);
-}
+ const uint8_t *p = _p;
-static inline void __put_unaligned_be64(uint64_t val, uint8_t *p)
-{
- __put_unaligned_be32(val >> 32, p);
- __put_unaligned_be32(val, p + 4);
+ return (uint64_t)get_unaligned_be32(p) << 32 |
+ get_unaligned_be32(p + 4);
}
-static inline uint16_t get_unaligned_be16(const void *p)
+static inline void put_unaligned_be16(uint16_t val, void *_p)
{
- return __get_unaligned_be16((const uint8_t *)p);
-}
+ uint8_t *p = _p;
-static inline uint32_t get_unaligned_be32(const void *p)
-{
- return __get_unaligned_be32((const uint8_t *)p);
+ *p++ = val >> 8;
+ *p++ = val;
}
-static inline uint64_t get_unaligned_be64(const void *p)
+static inline void put_unaligned_be32(uint32_t val, void *_p)
{
- return __get_unaligned_be64((const uint8_t *)p);
-}
+ uint8_t *p = _p;
-static inline void put_unaligned_be16(uint16_t val, void *p)
-{
- __put_unaligned_be16(val, p);
+ put_unaligned_be16(val >> 16, p);
+ put_unaligned_be16(val, p + 2);
}
-static inline void put_unaligned_be32(uint32_t val, void *p)
+static inline void put_unaligned_be64(uint64_t val, void *_p)
{
- __put_unaligned_be32(val, p);
-}
+ uint8_t *p = _p;
-static inline void put_unaligned_be64(uint64_t val, void *p)
-{
- __put_unaligned_be64(val, p);
+ put_unaligned_be32(val >> 32, p);
+ put_unaligned_be32(val, p + 4);
}
#endif /* _TOOLS_BE_BYTESHIFT_H */
diff --git a/tools/include/tools/le_byteshift.h b/tools/include/tools/le_byteshift.h
index 8fe9f2488ec7..819ba186ede5 100644
--- a/tools/include/tools/le_byteshift.h
+++ b/tools/include/tools/le_byteshift.h
@@ -3,68 +3,50 @@
#include <stdint.h>
-static inline uint16_t __get_unaligned_le16(const uint8_t *p)
+static inline uint16_t get_unaligned_le16(const void *_p)
{
- return p[0] | p[1] << 8;
-}
+ const uint8_t *p = _p;
-static inline uint32_t __get_unaligned_le32(const uint8_t *p)
-{
- return p[0] | p[1] << 8 | p[2] << 16 | p[3] << 24;
+ return p[0] | p[1] << 8;
}
-static inline uint64_t __get_unaligned_le64(const uint8_t *p)
+static inline uint32_t get_unaligned_le32(const void *_p)
{
- return (uint64_t)__get_unaligned_le32(p + 4) << 32 |
- __get_unaligned_le32(p);
-}
+ const uint8_t *p = _p;
-static inline void __put_unaligned_le16(uint16_t val, uint8_t *p)
-{
- *p++ = val;
- *p++ = val >> 8;
+ return p[0] | p[1] << 8 | p[2] << 16 | p[3] << 24;
}
-static inline void __put_unaligned_le32(uint32_t val, uint8_t *p)
+static inline uint64_t get_unaligned_le64(const void *_p)
{
- __put_unaligned_le16(val >> 16, p + 2);
- __put_unaligned_le16(val, p);
-}
+ const uint8_t *p = _p;
-static inline void __put_unaligned_le64(uint64_t val, uint8_t *p)
-{
- __put_unaligned_le32(val >> 32, p + 4);
- __put_unaligned_le32(val, p);
+ return (uint64_t)get_unaligned_le32(p + 4) << 32 |
+ get_unaligned_le32(p);
}
-static inline uint16_t get_unaligned_le16(const void *p)
+static inline void put_unaligned_le16(uint16_t val, void *_p)
{
- return __get_unaligned_le16((const uint8_t *)p);
-}
+ uint8_t *p = _p;
-static inline uint32_t get_unaligned_le32(const void *p)
-{
- return __get_unaligned_le32((const uint8_t *)p);
+ *p++ = val;
+ *p++ = val >> 8;
}
-static inline uint64_t get_unaligned_le64(const void *p)
+static inline void put_unaligned_le32(uint32_t val, void *_p)
{
- return __get_unaligned_le64((const uint8_t *)p);
-}
+ uint8_t *p = _p;
-static inline void put_unaligned_le16(uint16_t val, void *p)
-{
- __put_unaligned_le16(val, p);
+ put_unaligned_le16(val, p);
+ put_unaligned_le16(val >> 16, p + 2);
}
-static inline void put_unaligned_le32(uint32_t val, void *p)
+static inline void put_unaligned_le64(uint64_t val, void *_p)
{
- __put_unaligned_le32(val, p);
-}
+ uint8_t *p = _p;
-static inline void put_unaligned_le64(uint64_t val, void *p)
-{
- __put_unaligned_le64(val, p);
+ put_unaligned_le32(val, p);
+ put_unaligned_le32(val >> 32, p + 4);
}
#endif /* _TOOLS_LE_BYTESHIFT_H */
--
1.9.3
next prev parent reply other threads:[~2014-06-10 23:14 UTC|newest]
Thread overview: 18+ messages / expand[flat|nested] mbox.gz Atom feed top
2014-06-10 23:13 [PATCH RFC 00/10] tools: Revamp the unaligned endian access functions H. Peter Anvin
2014-06-10 23:13 ` H. Peter Anvin [this message]
2014-06-10 23:13 ` [PATCH RFC 02/10] tools: Create <tools/unaligned.h> and an unaligned subdirectory H. Peter Anvin
2014-06-10 23:13 ` [PATCH RFC 03/10] tools: Add le_direct/be_direct methods for unaligned access H. Peter Anvin
2014-06-10 23:25 ` Andy Lutomirski
2014-06-10 23:30 ` H. Peter Anvin
2014-06-10 23:33 ` Andy Lutomirski
2014-06-10 23:41 ` H. Peter Anvin
2014-06-10 23:13 ` [PATCH RFC 04/10] tools: Add packed struct method for unaligned references H. Peter Anvin
2014-06-10 23:13 ` [PATCH RFC 05/10] tools: Add <endian.h> libc support " H. Peter Anvin
2014-06-10 23:13 ` [PATCH RFC 06/10] tools: Add gcc __builtin_bswap*() " H. Peter Anvin
2014-06-10 23:13 ` [PATCH RFC 07/10] tools: Remove leading underscores from header guards H. Peter Anvin
2014-06-10 23:13 ` [PATCH RFC 08/10] tools: Move unaligned common infrastructure into <tools/unaligned.h> H. Peter Anvin
2014-06-10 23:13 ` [PATCH RFC 09/10] tools: Add common infrastructure for byte swapping H. Peter Anvin
2014-06-10 23:13 ` [PATCH RFC 10/10] tools: Use reasonable defaults for the default access H. Peter Anvin
2014-06-11 19:21 ` [PATCH RFC 00/10] tools: Revamp the unaligned endian access functions Sam Ravnborg
2014-06-11 21:52 ` H. Peter Anvin
2014-06-13 20:04 ` Sam Ravnborg
Reply instructions:
You may reply publicly to this message via plain-text email
using any one of the following methods:
* Save the following mbox file, import it into your mail client,
and reply-to-all from there: mbox
Avoid top-posting and favor interleaved quoting:
https://en.wikipedia.org/wiki/Posting_style#Interleaved_style
* Reply using the --to, --cc, and --in-reply-to
switches of git-send-email(1):
git send-email \
--in-reply-to=1402441994-16780-2-git-send-email-hpa@zytor.com \
--to=hpa@zytor.com \
--cc=akpm@linux-foundation.org \
--cc=linux-arch@vger.kernel.org \
--cc=linux-kbuild@vger.kernel.org \
--cc=linux-kernel@vger.kernel.org \
--cc=luto@amacapital.net \
--cc=mingo@kernel.org \
--cc=sam@ravnborg.org \
--cc=tglx@linutronix.de \
/path/to/YOUR_REPLY
https://kernel.org/pub/software/scm/git/docs/git-send-email.html
* If your mail client supports setting the In-Reply-To header
via mailto: links, try the mailto: link
Be sure your reply has a Subject: header at the top and a blank line
before the message body.
This is a public inbox, see mirroring instructions
for how to clone and mirror all data and code used for this inbox;
as well as URLs for NNTP newsgroup(s).