LXR linux/include/asm-alpha/unaligned.h

   1#ifndef __ALPHA_UNALIGNED_H
   2#define __ALPHA_UNALIGNED_H
   3
   4/* 
   5 * The main single-value unaligned transfer routines.
   6 */
   7#define get_unaligned(ptr) \
   8        ((__typeof__(*(ptr)))__get_unaligned((ptr), sizeof(*(ptr))))
   9#define put_unaligned(x,ptr) \
  10        __put_unaligned((unsigned long)(x), (ptr), sizeof(*(ptr)))
  11
  12/*
  13 * This is a silly but good way to make sure that
  14 * the get/put functions are indeed always optimized,
  15 * and that we use the correct sizes.
  16 */
  17extern void bad_unaligned_access_length(void) __attribute__((noreturn));
  18
  19/*
  20 * EGCS 1.1 knows about arbitrary unaligned loads.  Define some
  21 * packed structures to talk about such things with.
  22 */
  23
  24struct __una_u64 { __u64 x __attribute__((packed)); };
  25struct __una_u32 { __u32 x __attribute__((packed)); };
  26struct __una_u16 { __u16 x __attribute__((packed)); };
  27
  28/*
  29 * Elemental unaligned loads 
  30 */
  31
  32extern inline unsigned long __uldq(const unsigned long * r11)
  33{
  34        const struct __una_u64 *ptr = (const struct __una_u64 *) r11;
  35        return ptr->x;
  36}
  37
  38extern inline unsigned long __uldl(const unsigned int * r11)
  39{
  40        const struct __una_u32 *ptr = (const struct __una_u32 *) r11;
  41        return ptr->x;
  42}
  43
  44extern inline unsigned long __uldw(const unsigned short * r11)
  45{
  46        const struct __una_u16 *ptr = (const struct __una_u16 *) r11;
  47        return ptr->x;
  48}
  49
  50/*
  51 * Elemental unaligned stores 
  52 */
  53
  54extern inline void __ustq(unsigned long r5, unsigned long * r11)
  55{
  56        struct __una_u64 *ptr = (struct __una_u64 *) r11;
  57        ptr->x = r5;
  58}
  59
  60extern inline void __ustl(unsigned long r5, unsigned int * r11)
  61{
  62        struct __una_u32 *ptr = (struct __una_u32 *) r11;
  63        ptr->x = r5;
  64}
  65
  66extern inline void __ustw(unsigned long r5, unsigned short * r11)
  67{
  68        struct __una_u16 *ptr = (struct __una_u16 *) r11;
  69        ptr->x = r5;
  70}
  71
  72extern inline unsigned long __get_unaligned(const void *ptr, size_t size)
  73{
  74        unsigned long val;
  75        switch (size) {
  76              case 1:
  77                val = *(const unsigned char *)ptr;
  78                break;
  79              case 2:
  80                val = __uldw((const unsigned short *)ptr);
  81                break;
  82              case 4:
  83                val = __uldl((const unsigned int *)ptr);
  84                break;
  85              case 8:
  86                val = __uldq((const unsigned long *)ptr);
  87                break;
  88              default:
  89                bad_unaligned_access_length();
  90        }
  91        return val;
  92}
  93
  94extern inline void __put_unaligned(unsigned long val, void *ptr, size_t size)
  95{
  96        switch (size) {
  97              case 1:
  98                *(unsigned char *)ptr = (val);
  99                break;
 100              case 2:
 101                __ustw(val, (unsigned short *)ptr);
 102                break;
 103              case 4:
 104                __ustl(val, (unsigned int *)ptr);
 105                break;
 106              case 8:
 107                __ustq(val, (unsigned long *)ptr);
 108                break;
 109              default:
 110                bad_unaligned_access_length();
 111        }
 112}
 113
 114#endif
 115