129 lines
4.2 KiB
Diff
129 lines
4.2 KiB
Diff
# Make get_unaligned() work with const pointers and GCC 4.1
|
|
|
|
# See
|
|
# http://lists.arm.linux.org.uk/pipermail/linux-arm-kernel/2006-September/035862.html
|
|
|
|
|
|
From: Lennert Buytenhek <buytenh@wantstofly.org>
|
|
|
|
On Wed, Sep 06, 2006 at 09:32:58AM +0100, Russell King - ARM Linux wrote:
|
|
> > CC [M] drivers/net/wireless/zd1211rw/zd_usb.o
|
|
> > drivers/net/wireless/zd1211rw/zd_usb.c: In function 'handle_rx_packet':
|
|
> > drivers/net/wireless/zd1211rw/zd_usb.c:547: error: assignment of read-only variable '__v'
|
|
> > This comes from
|
|
> > if (get_unaligned(&length_info->tag) == cpu_to_le16(RX_LENGTH_INFO_TAG))
|
|
> > which gets expanded to arm's __get_unaligned_le(). The code ends up
|
|
> > being something like:
|
|
|
|
The attached patch makes get_unaligned() work with const pointers,
|
|
and doesn't seem to noticably affect code generation.
|
|
|
|
Original code (2.6.18-rc5), format is instructions/registers:
|
|
|
|
2.95.3 3.2.3 3.3.3 3.4.2 4.0.2 4.1.0
|
|
original, u8 1/1 1/1 1/1 1/1 1/1 1/1
|
|
original, u16 3/2 3/3 3/3 3/2 3/2 3/2
|
|
original, u32 7/4 8/5 9/5 7/5 7/4 8/5
|
|
original, u64 19/8 19/8 21/8 19/7 20/9 22/11
|
|
|
|
|
|
After patch (* denotes change):
|
|
|
|
2.95.3 3.2.3 3.3.3 3.4.2 4.0.2 4.1.0
|
|
fixed, u8 1/1 1/1 1/1 1/1 1/1 1/1
|
|
fixed, u16 3/2 3/3 3/3 3/2 3/2 3/2
|
|
fixed, u32 7/4 9/6 * 9/6 * 7/5 7/4 8/5
|
|
fixed, u64 19/8 19/8 20/8 * 19/7 20/9 22/11
|
|
|
|
|
|
So, for gcc 3.2.3 in the u32 case we need 1 insn and 1 register more,
|
|
on gcc 3.3.3 we need 1 reg more in the u32 case and save one insn in
|
|
the u64 case, and all the other compiler versions don't seem to care
|
|
at all.
|
|
|
|
|
|
--- a/include/asm-arm/unaligned.h.orig 2006-09-07 00:36:56.937552584 +0200
|
|
+++ b/include/asm-arm/unaligned.h 2006-09-07 02:03:40.522487432 +0200
|
|
@@ -3,7 +3,7 @@
|
|
|
|
#include <asm/types.h>
|
|
|
|
-extern int __bug_unaligned_x(void *ptr);
|
|
+extern int __bug_unaligned_x(const void *ptr);
|
|
|
|
/*
|
|
* What is the most efficient way of loading/storing an unaligned value?
|
|
@@ -51,47 +51,34 @@
|
|
#define __get_unaligned_4_be(__p) \
|
|
(__p[0] << 24 | __p[1] << 16 | __p[2] << 8 | __p[3])
|
|
|
|
-#define __get_unaligned_le(ptr) \
|
|
- ({ \
|
|
- __typeof__(*(ptr)) __v; \
|
|
- __u8 *__p = (__u8 *)(ptr); \
|
|
- switch (sizeof(*(ptr))) { \
|
|
- case 1: __v = *(ptr); break; \
|
|
- case 2: __v = __get_unaligned_2_le(__p); break; \
|
|
- case 4: __v = __get_unaligned_4_le(__p); break; \
|
|
- case 8: { \
|
|
- unsigned int __v1, __v2; \
|
|
- __v2 = __get_unaligned_4_le((__p+4)); \
|
|
- __v1 = __get_unaligned_4_le(__p); \
|
|
- __v = ((unsigned long long)__v2 << 32 | __v1); \
|
|
- } \
|
|
- break; \
|
|
- default: __v = __bug_unaligned_x(__p); break; \
|
|
- } \
|
|
- __v; \
|
|
+#define __get_unaligned_8_le(__p) \
|
|
+ ((unsigned long long)__get_unaligned_4_le((__p+4)) << 32 | \
|
|
+ __get_unaligned_4_le(__p))
|
|
+
|
|
+#define __get_unaligned_8_be(__p) \
|
|
+ ((unsigned long long)__get_unaligned_4_le(__p) << 32 | \
|
|
+ __get_unaligned_4_le((__p+4)))
|
|
+
|
|
+#define __get_unaligned_le(ptr) \
|
|
+ ({ \
|
|
+ const __u8 *__p = (const __u8 *)(ptr); \
|
|
+ sizeof(*(ptr)) == 1 ? *__p : \
|
|
+ sizeof(*(ptr)) == 2 ? __get_unaligned_2_le(__p) : \
|
|
+ sizeof(*(ptr)) == 4 ? __get_unaligned_4_le(__p) : \
|
|
+ sizeof(*(ptr)) == 8 ? __get_unaligned_8_le(__p) : \
|
|
+ __bug_unaligned_x(__p); \
|
|
})
|
|
|
|
-#define __get_unaligned_be(ptr) \
|
|
- ({ \
|
|
- __typeof__(*(ptr)) __v; \
|
|
- __u8 *__p = (__u8 *)(ptr); \
|
|
- switch (sizeof(*(ptr))) { \
|
|
- case 1: __v = *(ptr); break; \
|
|
- case 2: __v = __get_unaligned_2_be(__p); break; \
|
|
- case 4: __v = __get_unaligned_4_be(__p); break; \
|
|
- case 8: { \
|
|
- unsigned int __v1, __v2; \
|
|
- __v2 = __get_unaligned_4_be(__p); \
|
|
- __v1 = __get_unaligned_4_be((__p+4)); \
|
|
- __v = ((unsigned long long)__v2 << 32 | __v1); \
|
|
- } \
|
|
- break; \
|
|
- default: __v = __bug_unaligned_x(__p); break; \
|
|
- } \
|
|
- __v; \
|
|
+#define __get_unaligned_be(ptr) \
|
|
+ ({ \
|
|
+ const __u8 *__p = (const __u8 *)(ptr); \
|
|
+ sizeof(*(ptr)) == 1 ? *__p : \
|
|
+ sizeof(*(ptr)) == 2 ? __get_unaligned_2_be(__p) : \
|
|
+ sizeof(*(ptr)) == 4 ? __get_unaligned_4_be(__p) : \
|
|
+ sizeof(*(ptr)) == 8 ? __get_unaligned_8_be(__p) : \
|
|
+ __bug_unaligned_x(__p); \
|
|
})
|
|
|
|
-
|
|
static inline void __put_unaligned_2_le(__u32 __v, register __u8 *__p)
|
|
{
|
|
*__p++ = __v;
|
|
|