home *** CD-ROM | disk | FTP | other *** search
/ H4CK3R 4 / hacker04 / 04_HACK04.ISO / darwin / darwinx86.iso / usr / include / libkern / ppc / OSByteOrder.h
Encoding:
C/C++ Source or Header  |  2001-09-30  |  4.4 KB  |  208 lines
  1. /*
  2.  * Copyright (c) 2000 Apple Computer, Inc. All rights reserved.
  3.  *
  4.  * @APPLE_LICENSE_HEADER_START@
  5.  * 
  6.  * The contents of this file constitute Original Code as defined in and
  7.  * are subject to the Apple Public Source License Version 1.1 (the
  8.  * "License").  You may not use this file except in compliance with the
  9.  * License.  Please obtain a copy of the License at
  10.  * http://www.apple.com/publicsource and read it before using this file.
  11.  * 
  12.  * This Original Code and all software distributed under the License are
  13.  * distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY KIND, EITHER
  14.  * EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES,
  15.  * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY,
  16.  * FITNESS FOR A PARTICULAR PURPOSE OR NON-INFRINGEMENT.  Please see the
  17.  * License for the specific language governing rights and limitations
  18.  * under the License.
  19.  * 
  20.  * @APPLE_LICENSE_HEADER_END@
  21.  */
  22. /*
  23.  * Copyright (c) 1999 Apple Computer, Inc.  All rights reserved. 
  24.  *
  25.  * HISTORY
  26.  *
  27.  */
  28.  
  29.  
  30. #ifndef _OS_OSBYTEORDERPPC_H
  31. #define _OS_OSBYTEORDERPPC_H
  32.  
  33. #include <libkern/OSBase.h>
  34.  
  35. /* Functions for byte reversed loads. */
  36.  
  37. OS_INLINE
  38. UInt16
  39. OSReadSwapInt16(
  40.     volatile void               * base,
  41.     UInt                          offset
  42. )
  43. {
  44.     UInt16 result;
  45.     __asm__ volatile("lhbrx %0, %1, %2"
  46.                      : "=r" (result)
  47.                      : "b"  (base), "r" (offset)
  48.                      : "memory");
  49.     return result;
  50. }
  51.  
  52. OS_INLINE
  53. UInt32
  54. OSReadSwapInt32(
  55.     volatile void               * base,
  56.     UInt                          offset
  57. )
  58. {
  59.     UInt32 result;
  60.     __asm__ volatile("lwbrx %0, %1, %2"
  61.                      : "=r" (result)
  62.                      : "b"  (base), "r" (offset)
  63.                      : "memory");
  64.     return result;
  65. }
  66.  
  67. OS_INLINE
  68. UInt64
  69. OSReadSwapInt64(
  70.     volatile void               * base,
  71.     UInt                          offset
  72. )
  73. {
  74.     UInt64 * inp;
  75.     union ullc {
  76.         UInt64     ull;
  77.         UInt       ul[2];
  78.     } outv;
  79.  
  80.     inp = (UInt64 *)base;
  81.     outv.ul[0] = OSReadSwapInt32(inp, offset + 4);
  82.     outv.ul[1] = OSReadSwapInt32(inp, offset);
  83.     return outv.ull;
  84. }
  85.  
  86. OS_INLINE
  87. UInt
  88. OSReadSwapInt(
  89.     volatile void               * base,
  90.     UInt                          offset
  91. )
  92. {
  93.     UInt result;
  94.     __asm__ volatile("lwbrx %0, %1, %2"
  95.                      : "=r" (result)
  96.                      : "b"  (base), "r" (offset)
  97.                      : "memory");
  98.     return result;
  99. }
  100.  
  101. /* Functions for byte reversed stores. */
  102.  
  103. OS_INLINE
  104. void
  105. OSWriteSwapInt16(
  106.     volatile void               * base,
  107.     UInt                          offset,
  108.     UInt16                        data
  109. )
  110. {
  111.     __asm__ volatile("sthbrx %0, %1, %2"
  112.                      :
  113.                      : "r" (data), "b" (base), "r" (offset)
  114.                      : "memory");
  115. }
  116.  
  117. OS_INLINE
  118. void
  119. OSWriteSwapInt32(
  120.     volatile void               * base,
  121.     UInt                          offset,
  122.     UInt32                        data
  123. )
  124. {
  125.     __asm__ volatile("stwbrx %0, %1, %2"
  126.                      :
  127.                      : "r" (data), "b" (base), "r" (offset)
  128.                      : "memory" );
  129. }
  130.  
  131. OS_INLINE
  132. void
  133. OSWriteSwapInt64(
  134.     volatile void               * base,
  135.     UInt                          offset,
  136.     UInt64                        data
  137. )
  138. {
  139.     UInt64 * outp;
  140.     union ullc {
  141.         UInt64     ull;
  142.         UInt       ul[2];
  143.     } *inp;
  144.  
  145.     outp = (UInt64 *)base;
  146.     inp  = (union ullc *)&data;
  147.     OSWriteSwapInt32(outp, offset, inp->ul[1]);
  148.     OSWriteSwapInt32(outp, offset + 4, inp->ul[0]);
  149. }
  150.  
  151. OS_INLINE
  152. void
  153. OSWriteSwapInt(
  154.     volatile void               * base,
  155.     UInt                          offset,
  156.     UInt                          data
  157. )
  158. {
  159.     __asm__ volatile("stwbrx %0, %1, %2"
  160.                      :
  161.                      : "r" (data), "b" (base), "r" (offset)
  162.                      : "memory" );
  163. }
  164.  
  165. /* Generic byte swapping functions. */
  166.  
  167. OS_INLINE
  168. UInt16
  169. OSSwapInt16(
  170.     UInt16                        data
  171. )
  172. {
  173.     UInt16 temp = data;
  174.     return OSReadSwapInt16(&temp, 0);
  175. }
  176.  
  177. OS_INLINE
  178. UInt32
  179. OSSwapInt32(
  180.     UInt32                        data
  181. )
  182. {
  183.     UInt32 temp = data;
  184.     return OSReadSwapInt32(&temp, 0);
  185. }
  186.  
  187. OS_INLINE
  188. UInt64
  189. OSSwapInt64(
  190.     UInt64                        data
  191. )
  192. {
  193.     UInt64 temp = data;
  194.     return OSReadSwapInt64(&temp, 0);
  195. }
  196.  
  197. OS_INLINE
  198. UInt
  199. OSSwapInt(
  200.     UInt                          data
  201. )
  202. {
  203.     UInt temp = data;
  204.     return OSReadSwapInt(&temp, 0);
  205. }
  206.  
  207. #endif /* ! _OS_OSBYTEORDERPPC_H */
  208.