include/asm-arm/unaligned.h

   1 #ifndef __ASM_ARM_UNALIGNED_H
   2 #define __ASM_ARM_UNALIGNED_H
   3
   4 #include <asm/types.h>
   5
   6 extern int __bug_unaligned_x(const void *ptr);
   7
   8 /*
   9  * What is the most efficient way of loading/storing an unaligned value?
  10  *
  11  * That is the subject of this file.  Efficiency here is defined as
  12  * minimum code size with minimum register usage for the common cases.
  13  * It is currently not believed that long longs are common, so we
  14  * trade efficiency for the chars, shorts and longs against the long
  15  * longs.
  16  *
  17  * Current stats with gcc 2.7.2.2 for these functions:
  18  *
  19  *      ptrsize get:    code    regs    put:    code    regs
  20  *      1               1       1               1       2
  21  *      2               3       2               3       2
  22  *      4               7       3               7       3
  23  *      8               20      6               16      6
  24  *
  25  * gcc 2.95.1 seems to code differently:
  26  *
  27  *      ptrsize get:    code    regs    put:    code    regs
  28  *      1               1       1               1       2
  29  *      2               3       2               3       2
  30  *      4               7       4               7       4
  31  *      8               19      8               15      6
  32  *
  33  * which may or may not be more efficient (depending upon whether
  34  * you can afford the extra registers).  Hopefully the gcc 2.95
  35  * is inteligent enough to decide if it is better to use the
  36  * extra register, but evidence so far seems to suggest otherwise.
  37  *
  38  * Unfortunately, gcc is not able to optimise the high word
  39  * out of long long >> 32, or the low word from long long << 32
  40  */
  41
  42 #define __get_unaligned_2_le(__p)                                       \
  43         (__p[0] | __p[1] << 8)
  44
  45 #define __get_unaligned_2_be(__p)                                       \
  46         (__p[0] << 8 | __p[1])
  47
  48 #define __get_unaligned_4_le(__p)                                       \
  49         (__p[0] | __p[1] << 8 | __p[2] << 16 | __p[3] << 24)
  50
  51 #define __get_unaligned_4_be(__p)                                       \
  52         (__p[0] << 24 | __p[1] << 16 | __p[2] << 8 | __p[3])
  53
  54 #define __get_unaligned_8_le(__p)                                       \
  55         ((unsigned long long)__get_unaligned_4_le((__p+4)) << 32 |      \
  56                 __get_unaligned_4_le(__p))
  57
  58 #define __get_unaligned_8_be(__p)                                       \
  59         ((unsigned long long)__get_unaligned_4_be(__p) << 32 |          \
  60                 __get_unaligned_4_be((__p+4)))
  61
  62 #if 0   // mask by Victor Yu. 02-12-2007
  63 #define __get_unaligned_le(ptr)                                         \
  64         ({                                                              \
  65                 const __u8 *__p = (const __u8 *)(ptr);                  \
  66                 __builtin_choose_expr(sizeof(*(ptr)) == 1, *__p,        \
  67                   __builtin_choose_expr(sizeof(*(ptr)) == 2, __get_unaligned_2_le(__p), \
  68                   __builtin_choose_expr(sizeof(*(ptr)) == 4, __get_unaligned_4_le(__p), \
  69                   __builtin_choose_expr(sizeof(*(ptr)) == 8, __get_unaligned_8_le(__p), \
  70                     (void)__bug_unaligned_x(__p)))));                   \
  71         })
  72 #else
  73 #define __get_unaligned_le(ptr) \
  74         ({      \
  75         __typeof__(*(ptr)) __v; \
  76         __u8 *__p = (__u8 *)(ptr);      \
  77         switch (sizeof(*(ptr))) {                       \
  78         case 1: __v = *(ptr);                   break;  \
  79         case 2: __v = __get_unaligned_2_le(__p);        break;  \
  80         case 4: __v = __get_unaligned_4_le(__p);        break;  \
  81         case 8: {                                       \
  82                 unsigned int __v1, __v2;        \
  83                 __v2 = __get_unaligned_4_le((__p+4)); \
  84                 __v1 = __get_unaligned_4_le(__p);       \
  85                 __v = ((unsigned long long)__v2 << 32 | __v1);  \
  86         }                                       \
  87                 break;                                  \
  88         default: __v = __bug_unaligned_x(__p);  break;  \
  89         }                                               \
  90         __v;                                            \
  91         })
  92 #endif
  93
  94 #define __get_unaligned_be(ptr)                                         \
  95         ({                                                              \
  96                 const __u8 *__p = (const __u8 *)(ptr);                  \
  97                 __builtin_choose_expr(sizeof(*(ptr)) == 1, *__p,        \
  98                   __builtin_choose_expr(sizeof(*(ptr)) == 2, __get_unaligned_2_be(__p), \
  99                   __builtin_choose_expr(sizeof(*(ptr)) == 4, __get_unaligned_4_be(__p), \
 100                   __builtin_choose_expr(sizeof(*(ptr)) == 8, __get_unaligned_8_be(__p), \
 101                     (void)__bug_unaligned_x(__p)))));                   \
 102         })
 103
 104
 105 static inline void __put_unaligned_2_le(__u32 __v, register __u8 *__p)
 106 {
 107         *__p++ = __v;
 108         *__p++ = __v >> 8;
 109 }
 110
 111 static inline void __put_unaligned_2_be(__u32 __v, register __u8 *__p)
 112 {
 113         *__p++ = __v >> 8;
 114         *__p++ = __v;
 115 }
 116
 117 static inline void __put_unaligned_4_le(__u32 __v, register __u8 *__p)
 118 {
 119         __put_unaligned_2_le(__v >> 16, __p + 2);
 120         __put_unaligned_2_le(__v, __p);
 121 }
 122
 123 static inline void __put_unaligned_4_be(__u32 __v, register __u8 *__p)
 124 {
 125         __put_unaligned_2_be(__v >> 16, __p);
 126         __put_unaligned_2_be(__v, __p + 2);
 127 }
 128
 129 static inline void __put_unaligned_8_le(const unsigned long long __v, register __u8 *__p)
 130 {
 131         /*
 132          * tradeoff: 8 bytes of stack for all unaligned puts (2
 133          * instructions), or an extra register in the long long
 134          * case - go for the extra register.
 135          */
 136         __put_unaligned_4_le(__v >> 32, __p+4);
 137         __put_unaligned_4_le(__v, __p);
 138 }
 139
 140 static inline void __put_unaligned_8_be(const unsigned long long __v, register __u8 *__p)
 141 {
 142         /*
 143          * tradeoff: 8 bytes of stack for all unaligned puts (2
 144          * instructions), or an extra register in the long long
 145          * case - go for the extra register.
 146          */
 147         __put_unaligned_4_be(__v >> 32, __p);
 148         __put_unaligned_4_be(__v, __p+4);
 149 }
 150
 151 /*
 152  * Try to store an unaligned value as efficiently as possible.
 153  */
 154 #define __put_unaligned_le(val,ptr)                                     \
 155         ({                                                      \
 156                 switch (sizeof(*(ptr))) {                       \
 157                 case 1:                                         \
 158                         *(ptr) = (val);                         \
 159                         break;                                  \
 160                 case 2: __put_unaligned_2_le((val),(__u8 *)(ptr));      \
 161                         break;                                  \
 162                 case 4: __put_unaligned_4_le((val),(__u8 *)(ptr));      \
 163                         break;                                  \
 164                 case 8: __put_unaligned_8_le((val),(__u8 *)(ptr)); \
 165                         break;                                  \
 166                 default: __bug_unaligned_x(ptr);                \
 167                         break;                                  \
 168                 }                                               \
 169                 (void) 0;                                       \
 170         })
 171
 172 #define __put_unaligned_be(val,ptr)                                     \
 173         ({                                                      \
 174                 switch (sizeof(*(ptr))) {                       \
 175                 case 1:                                         \
 176                         *(ptr) = (val);                         \
 177                         break;                                  \
 178                 case 2: __put_unaligned_2_be((val),(__u8 *)(ptr));      \
 179                         break;                                  \
 180                 case 4: __put_unaligned_4_be((val),(__u8 *)(ptr));      \
 181                         break;                                  \
 182                 case 8: __put_unaligned_8_be((val),(__u8 *)(ptr)); \
 183                         break;                                  \
 184                 default: __bug_unaligned_x(ptr);                \
 185                         break;                                  \
 186                 }                                               \
 187                 (void) 0;                                       \
 188         })
 189
 190 /*
 191  * Select endianness
 192  */
 193 #ifndef __ARMEB__
 194 #define get_unaligned   __get_unaligned_le
 195 #define put_unaligned   __put_unaligned_le
 196 #else
 197 #define get_unaligned   __get_unaligned_be
 198 #define put_unaligned   __put_unaligned_be
 199 #endif
 200
 201 #endif