2.2.18pre10

 include

 asm-arm

diff -u --new-file --recursive --exclude-from /usr/src/exclude linux.vanilla/include/asm-arm/unaligned.h linux.18p10/include/asm-arm+
/unaligned.h
--- linux.vanilla/include/asm-arm/unaligned.h   Fri Apr 21 12:46:49 2000
+++ linux.18p10/include/asm-arm/unaligned.h   Fri Sep 15 23:32:35 2000
@@ -1,59 +1,115 @@
-#ifndef __ARM_UNALIGNED_H
-#define __ARM_UNALIGNED_H
+#ifndef __ASM_ARM_UNALIGNED_H
+#define __ASM_ARM_UNALIGNED_H
 
-#define get_unaligned(ptr) \
-   ((__typeof__(*(ptr)))__get_unaligned((ptr), sizeof(*(ptr))))
+#include <asm/types.h>
 
-#define put_unaligned(val, ptr) \
-   __put_unaligned((unsigned long)(val), (ptr), sizeof(*(ptr)))
+extern int __bug_unaligned_x(void *ptr);
 
-extern void bad_unaligned_access_length (void);
-   
-extern inline unsigned long __get_unaligned(const void *ptr, size_t size)
+/*
+ * What is the most efficient way of loading/storing an unaligned value?
+ *
+ * That is the subject of this file.  Efficiency here is defined as
+ * minimum code size with minimum register usage for the common cases.
+ * It is currently not believed that long longs are common, so we
+ * trade efficiency for the chars, shorts and longs against the long
+ * longs.
+ *
+ * Current stats with gcc 2.7.2.2 for these functions:
+ *
+ *   ptrsize   get:   code   regs   put:   code   regs
+ *   1      1   1      1   2
+ *   2      3   2      3   2
+ *   4      7   3      7   3
+ *   8      20   6      16   6
+ *
+ * gcc 2.95.1 seems to code differently:
+ *
+ *   ptrsize   get:   code   regs   put:   code   regs
+ *   1      1   1      1   2
+ *   2      3   2      3   2
+ *   4      7   4      7   4
+ *   8      19   8      15   6
+ *
+ * which may or may not be more efficient (depending upon whether
+ * you can afford the extra registers).  Hopefully the gcc 2.95
+ * is inteligent enough to decide if it is better to use the
+ * extra register, but evidence so far seems to suggest otherwise.
+ *
+ * Unfortunately, gcc is not able to optimise the high word
+ * out of long long >> 32, or the low word from long long << 32
+ */
+
+#define __get_unaligned_2(__p)               \
+   (__p[0] | __p[1] << 8)
+
+#define __get_unaligned_4(__p)               \
+   (__p[0] | __p[1] << 8 | __p[2] << 16 | __p[3] << 24)
+
+#define get_unaligned(ptr)               \
+   ({                     \
+      __typeof__(*(ptr)) __v;            \
+      __u8 *__p = (__u8 *)(ptr);         \
+      switch (sizeof(*(ptr))) {         \
+      case 1:   __v = *(ptr);         break;   \
+      case 2: __v = __get_unaligned_2(__p);   break;   \
+      case 4: __v = __get_unaligned_4(__p);   break;   \
+      case 8: {               \
+            unsigned int __v1, __v2;   \
+            __v2 = __get_unaligned_4((__p+4)); \
+            __v1 = __get_unaligned_4(__p);   \
+            __v = ((unsigned long long)__v2 << 32 | __v1);   \
+         }               \
+         break;               \
+      default: __v = __bug_unaligned_x(__p);   break;   \
+      }                  \
+      __v;                  \
+   })
+
+
+static inline void __put_unaligned_2(__u32 __v, register __u8 *__p)
+{
+   *__p++ = __v;
+   *__p++ = __v >> 8;
+}
+
+static inline void __put_unaligned_4(__u32 __v, register __u8 *__p)
 {
-    unsigned long val;
-    switch (size) {
-   case 1:
-       val = *(const unsigned char *)ptr;
-       break;
-
-   case 2:
-       val = ((const unsigned char *)ptr)[0] | (((const unsigned char *)ptr)[1] << 8);
-       break;
-
-   case 4:
-       val = ((const unsigned char *)ptr)[0]        | (((const unsigned char *)ptr)[1] << 8) |
-       (((const unsigned char *)ptr)[2]) << 16 | (((const unsigned char *)ptr)[3] << 24);
-       break;
-
-   default:
-       bad_unaligned_access_length ();
-    }
-    return val;
+   __put_unaligned_2(__v >> 16, __p + 2);
+   __put_unaligned_2(__v, __p);
 }
 
-extern inline void __put_unaligned(unsigned long val, void *ptr, size_t size)
+static inline void __put_unaligned_8(const unsigned long long __v, register __u8 *__p)
 {
-    switch (size) {
-   case 1:
-       *(unsigned char *)ptr = val;
-       break;
-
-   case 2:
-       ((unsigned char *)ptr)[0] = val;
-       ((unsigned char *)ptr)[1] = val >> 8;
-       break;
-
-   case 4:
-       ((unsigned char *)ptr)[0] = val;
-       ((unsigned char *)ptr)[1] = val >> 8;
-       ((unsigned char *)ptr)[2] = val >> 16;
-       ((unsigned char *)ptr)[3] = val >> 24;
-       break;
-
-   default:
-       bad_unaligned_access_length ();
-    }
+   /*
+    * tradeoff: 8 bytes of stack for all unaligned puts (2
+    * instructions), or an extra register in the long long
+    * case - go for the extra register.
+    */
+   __put_unaligned_4(__v >> 32, __p+4);
+   __put_unaligned_4(__v, __p);
 }
 
+/*
+ * Try to store an unaligned value as efficiently as possible.
+ */
+#define put_unaligned(val,ptr)               \
+   ({                     \
+      switch (sizeof(*(ptr))) {         \
+      case 1:                  \
+         *(ptr) = (val);            \
+         break;               \
+      case 2: __put_unaligned_2((val),(__u8 *)(ptr));   \
+         break;               \
+      case 4:   __put_unaligned_4((val),(__u8 *)(ptr));   \
+         break;               \
+      case 8:   __put_unaligned_8((val),(__u8 *)(ptr)); \
+         break;               \
+      default: __bug_unaligned_x(ptr);      \
+         break;               \
+      }                  \
+      (void) 0;               \
+   })
+
+
 #endif
+