Category

Development Platform
Home > SourceCode/Document > Linux-Unix program > View Code
unaligned.h
Package: linux-2.4.20.tar.gz　[view]
Upload User: jlfgdled
Upload Date: 2013-04-10
Package Size: 33168k
Code Size: 3k
Category:

Linux-Unix program

Development Platform:

Unix_Linux

unaligned.h：Code Content
  1. /*
  2.  * This file is subject to the terms and conditions of the GNU General Public
  3.  * License.  See the file "COPYING" in the main directory of this archive
  4.  * for more details.
  5.  *
  6.  * Copyright (C) 1996, 1999, 2000, 2001 by Ralf Baechle
  7.  * Copyright (C) 1999, 2000, 2001 Silicon Graphics, Inc.
  8.  */
  9. #ifndef _ASM_UNALIGNED_H
  10. #define _ASM_UNALIGNED_H
  12. extern void __get_unaligned_bad_length(void);
  13. extern void __put_unaligned_bad_length(void);
  15. /*
  16.  * Load quad unaligned.
  17.  */
  18. static inline unsigned long __ldq_u(const unsigned long * __addr)
  19. {
  20. unsigned long __res;
  22. __asm__("uldt%0,%1"
  23. : "=&r" (__res)
  24. : "m" (*__addr));
  26. return __res;
  27. }
  29. /*
  30.  * Load long unaligned.
  31.  */
  32. static inline unsigned long __ldl_u(const unsigned int * __addr)
  33. {
  34. unsigned long __res;
  36. __asm__("ulwt%0,%1"
  37. : "=&r" (__res)
  38. : "m" (*__addr));
  40. return __res;
  41. }
  43. /*
  44.  * Load word unaligned.
  45.  */
  46. static inline unsigned long __ldw_u(const unsigned short * __addr)
  47. {
  48. unsigned long __res;
  50. __asm__("ulht%0,%1"
  51. : "=&r" (__res)
  52. : "m" (*__addr));
  54. return __res;
  55. }
  57. /*
  58.  * Store quad ununaligned.
  59.  */
  60. static inline void __stq_u(unsigned long __val, unsigned long * __addr)
  61. {
  62. __asm__("usdt%1, %0"
  63. : "=m" (*__addr)
  64. : "r" (__val));
  65. }
  67. /*
  68.  * Store long ununaligned.
  69.  */
  70. static inline void __stl_u(unsigned long __val, unsigned int * __addr)
  71. {
  72. __asm__("uswt%1, %0"
  73. : "=m" (*__addr)
  74. : "r" (__val));
  75. }
  77. /*
  78.  * Store word ununaligned.
  79.  */
  80. static inline void __stw_u(unsigned long __val, unsigned short * __addr)
  81. {
  82. __asm__("usht%1, %0"
  83. : "=m" (*__addr)
  84. : "r" (__val));
  85. }
  87. /*
  88.  * get_unaligned - get value from possibly mis-aligned location
  89.  * @ptr: pointer to value
  90.  *
  91.  * This macro should be used for accessing values larger in size than
  92.  * single bytes at locations that are expected to be improperly aligned,
  93.  * e.g. retrieving a u16 value from a location not u16-aligned.
  94.  *
  95.  * Note that unaligned accesses can be very expensive on some architectures.
  96.  */
  97. #define get_unaligned(ptr)
  98. ({
  99. __typeof__(*(ptr)) __val;
  101. switch (sizeof(*(ptr))) {
  102. case 1:
  103. __val = *(const unsigned char *)(ptr);
  104. break;
  105. case 2:
  106. __val = __ldw_u((const unsigned short *)(ptr));
  107. break;
  108. case 4:
  109. __val = __ldl_u((const unsigned int *)(ptr));
  110. break;
  111. case 8:
  112. __val = __ldq_u((const unsigned long *)(ptr));
  113. break;
  114. default:
  115. __get_unaligned_bad_length();
  116. break;
  117. }
  119. __val;
  120. })
  122. /*
  123.  * put_unaligned - put value to a possibly mis-aligned location
  124.  * @val: value to place
  125.  * @ptr: pointer to location
  126.  *
  127.  * This macro should be used for placing values larger in size than
  128.  * single bytes at locations that are expected to be improperly aligned,
  129.  * e.g. writing a u16 value to a location not u16-aligned.
  130.  *
  131.  * Note that unaligned accesses can be very expensive on some architectures.
  132.  */
  133. #define put_unaligned(val,ptr)
  134. do {
  135. switch (sizeof(*(ptr))) {
  136. case 1:
  137. *(unsigned char *)(ptr) = (val);
  138. break;
  139. case 2:
  140. __stw_u((val), (unsigned short *)(ptr));
  141. break;
  142. case 4:
  143. __stl_u((val), (unsigned int *)(ptr));
  144. break;
  145. case 8:
  146. __stq_u((val), (unsigned long long *)(ptr));
  147. break;
  148. default:
  149. __put_unaligned_bad_length();
  150. break;
  151. }
  152. } while(0)
  154. #endif /* _ASM_UNALIGNED_H */