home *** CD-ROM | disk | FTP | other *** search
/ PC Welt 2006 November (DVD) / PCWELT_11_2006.ISO / casper / filesystem.squashfs / usr / src / linux-headers-2.6.17-6 / include / asm-arm / unaligned.h < prev    next >
Encoding:
C/C++ Source or Header  |  2006-08-11  |  4.9 KB  |  192 lines
  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(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_le(ptr)                    \
  55.     ({                            \
  56.         __typeof__(*(ptr)) __v;                \
  57.         __u8 *__p = (__u8 *)(ptr);            \
  58.         switch (sizeof(*(ptr))) {            \
  59.         case 1:    __v = *(ptr);            break;    \
  60.         case 2: __v = __get_unaligned_2_le(__p);    break;    \
  61.         case 4: __v = __get_unaligned_4_le(__p);    break;    \
  62.         case 8: {                    \
  63.                 unsigned int __v1, __v2;    \
  64.                 __v2 = __get_unaligned_4_le((__p+4)); \
  65.                 __v1 = __get_unaligned_4_le(__p);    \
  66.                 __v = ((unsigned long long)__v2 << 32 | __v1);    \
  67.             }                    \
  68.             break;                    \
  69.         default: __v = __bug_unaligned_x(__p);    break;    \
  70.         }                        \
  71.         __v;                        \
  72.     })
  73.  
  74. #define __get_unaligned_be(ptr)                    \
  75.     ({                            \
  76.         __typeof__(*(ptr)) __v;                \
  77.         __u8 *__p = (__u8 *)(ptr);            \
  78.         switch (sizeof(*(ptr))) {            \
  79.         case 1:    __v = *(ptr);            break;    \
  80.         case 2: __v = __get_unaligned_2_be(__p);    break;    \
  81.         case 4: __v = __get_unaligned_4_be(__p);    break;    \
  82.         case 8: {                    \
  83.                 unsigned int __v1, __v2;    \
  84.                 __v2 = __get_unaligned_4_be(__p); \
  85.                 __v1 = __get_unaligned_4_be((__p+4));    \
  86.                 __v = ((unsigned long long)__v2 << 32 | __v1);    \
  87.             }                    \
  88.             break;                    \
  89.         default: __v = __bug_unaligned_x(__p);    break;    \
  90.         }                        \
  91.         __v;                        \
  92.     })
  93.  
  94.  
  95. static inline void __put_unaligned_2_le(__u32 __v, register __u8 *__p)
  96. {
  97.     *__p++ = __v;
  98.     *__p++ = __v >> 8;
  99. }
  100.  
  101. static inline void __put_unaligned_2_be(__u32 __v, register __u8 *__p)
  102. {
  103.     *__p++ = __v >> 8;
  104.     *__p++ = __v;
  105. }
  106.  
  107. static inline void __put_unaligned_4_le(__u32 __v, register __u8 *__p)
  108. {
  109.     __put_unaligned_2_le(__v >> 16, __p + 2);
  110.     __put_unaligned_2_le(__v, __p);
  111. }
  112.  
  113. static inline void __put_unaligned_4_be(__u32 __v, register __u8 *__p)
  114. {
  115.     __put_unaligned_2_be(__v >> 16, __p);
  116.     __put_unaligned_2_be(__v, __p + 2);
  117. }
  118.  
  119. static inline void __put_unaligned_8_le(const unsigned long long __v, register __u8 *__p)
  120. {
  121.     /*
  122.      * tradeoff: 8 bytes of stack for all unaligned puts (2
  123.      * instructions), or an extra register in the long long
  124.      * case - go for the extra register.
  125.      */
  126.     __put_unaligned_4_le(__v >> 32, __p+4);
  127.     __put_unaligned_4_le(__v, __p);
  128. }
  129.  
  130. static inline void __put_unaligned_8_be(const unsigned long long __v, register __u8 *__p)
  131. {
  132.     /*
  133.      * tradeoff: 8 bytes of stack for all unaligned puts (2
  134.      * instructions), or an extra register in the long long
  135.      * case - go for the extra register.
  136.      */
  137.     __put_unaligned_4_be(__v >> 32, __p);
  138.     __put_unaligned_4_be(__v, __p+4);
  139. }
  140.  
  141. /*
  142.  * Try to store an unaligned value as efficiently as possible.
  143.  */
  144. #define __put_unaligned_le(val,ptr)                    \
  145.     ({                            \
  146.         switch (sizeof(*(ptr))) {            \
  147.         case 1:                        \
  148.             *(ptr) = (val);                \
  149.             break;                    \
  150.         case 2: __put_unaligned_2_le((val),(__u8 *)(ptr));    \
  151.             break;                    \
  152.         case 4:    __put_unaligned_4_le((val),(__u8 *)(ptr));    \
  153.             break;                    \
  154.         case 8:    __put_unaligned_8_le((val),(__u8 *)(ptr)); \
  155.             break;                    \
  156.         default: __bug_unaligned_x(ptr);        \
  157.             break;                    \
  158.         }                        \
  159.         (void) 0;                    \
  160.     })
  161.  
  162. #define __put_unaligned_be(val,ptr)                    \
  163.     ({                            \
  164.         switch (sizeof(*(ptr))) {            \
  165.         case 1:                        \
  166.             *(ptr) = (val);                \
  167.             break;                    \
  168.         case 2: __put_unaligned_2_be((val),(__u8 *)(ptr));    \
  169.             break;                    \
  170.         case 4:    __put_unaligned_4_be((val),(__u8 *)(ptr));    \
  171.             break;                    \
  172.         case 8:    __put_unaligned_8_be((val),(__u8 *)(ptr)); \
  173.             break;                    \
  174.         default: __bug_unaligned_x(ptr);        \
  175.             break;                    \
  176.         }                        \
  177.         (void) 0;                    \
  178.     })
  179.  
  180. /*
  181.  * Select endianness
  182.  */
  183. #ifndef __ARMEB__
  184. #define get_unaligned    __get_unaligned_le
  185. #define put_unaligned    __put_unaligned_le
  186. #else
  187. #define get_unaligned    __get_unaligned_be
  188. #define put_unaligned    __put_unaligned_be
  189. #endif
  190.  
  191. #endif
  192.