EXTERNAL_HEADERS/architecture/i386/byte_order.h

   1 /*
   2  * Copyright (c) 2000 Apple Computer, Inc. All rights reserved.
   3  *
   4  * @APPLE_LICENSE_OSREFERENCE_HEADER_START@
   5  *
   6  * This file contains Original Code and/or Modifications of Original Code
   7  * as defined in and that are subject to the Apple Public Source License
   8  * Version 2.0 (the 'License'). You may not use this file except in
   9  * compliance with the License.  The rights granted to you under the
  10  * License may not be used to create, or enable the creation or
  11  * redistribution of, unlawful or unlicensed copies of an Apple operating
  12  * system, or to circumvent, violate, or enable the circumvention or
  13  * violation of, any terms of an Apple operating system software license
  14  * agreement.
  15  *
  16  * Please obtain a copy of the License at
  17  * http://www.opensource.apple.com/apsl/ and read it before using this
  18  * file.
  19  *
  20  * The Original Code and all software distributed under the License are
  21  * distributed on an 'AS IS' basis, WITHOUT WARRANTY OF ANY KIND, EITHER
  22  * EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES,
  23  * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY,
  24  * FITNESS FOR A PARTICULAR PURPOSE, QUIET ENJOYMENT OR NON-INFRINGEMENT.
  25  * Please see the License for the specific language governing rights and
  26  * limitations under the License.
  27  *
  28  * @APPLE_LICENSE_OSREFERENCE_HEADER_END@
  29  */
  30 /*
  31  * Copyright (c) 1992 NeXT Computer, Inc.
  32  *
  33  * Byte ordering conversion (for i386).
  34  *
  35  * HISTORY
  36  *
  37  * 8 October 1992 ? at NeXT
  38  *      Converted to NXxxx versions.  Condensed history.
  39  *
  40  * 18 May 1992 ? at NeXT
  41  *      Created.
  42  */
  43
  44 static __inline__
  45 unsigned short
  46 NXSwapShort(
  47     unsigned short      inv
  48 )
  49 {
  50     register unsigned short value = inv;
  51
  52     __asm__ volatile( "xchgb %h1, %b1" : "=q" (value) : "0" (value));
  53
  54     return (value);
  55 }
  56
  57 static __inline__
  58 unsigned long
  59 NXSwapInt(
  60     unsigned long inv
  61 )
  62 {
  63     register unsigned int outv = inv;
  64
  65     __asm__ volatile( "bswap %0" : "=r" (outv) : "0" (outv));
  66
  67     return (outv);
  68 }
  69
  70 static __inline__
  71 unsigned long
  72 NXSwapLong(
  73     unsigned long       inv
  74 )
  75 {
  76     unsigned long       outv;
  77
  78     __asm__ volatile(
  79         "bswap %0"
  80
  81         : "=r"  (outv)
  82         : "0"   (inv));
  83
  84     return (outv);
  85 }
  86
  87 static __inline__
  88 unsigned long long
  89 NXSwapLongLong(
  90     unsigned long long  inv
  91 )
  92 {
  93     union llconv {
  94         unsigned long long      ull;
  95         unsigned long           ul[2];
  96     } *inp, outv;
  97
  98     inp = (union llconv *)&inv;
  99
 100     outv.ul[0] = NXSwapLong(inp->ul[1]);
 101     outv.ul[1] = NXSwapLong(inp->ul[0]);
 102
 103     return (outv.ull);
 104 }
 105
 106 static __inline__ NXSwappedFloat
 107 NXConvertHostFloatToSwapped(float x)
 108 {
 109     union fconv {
 110         float number;
 111         NXSwappedFloat sf;
 112     };
 113     return ((union fconv *)&x)->sf;
 114 }
 115
 116 static __inline__ float
 117 NXConvertSwappedFloatToHost(NXSwappedFloat x)
 118 {
 119     union fconv {
 120         float number;
 121         NXSwappedFloat sf;
 122     };
 123     return ((union fconv *)&x)->number;
 124 }
 125
 126 static __inline__ NXSwappedDouble
 127 NXConvertHostDoubleToSwapped(double x)
 128 {
 129     union dconv {
 130         double number;
 131         NXSwappedDouble sd;
 132     };
 133     return ((union dconv *)&x)->sd;
 134 }
 135
 136 static __inline__ double
 137 NXConvertSwappedDoubleToHost(NXSwappedDouble x)
 138 {
 139     union dconv {
 140         double number;
 141         NXSwappedDouble sd;
 142     };
 143     return ((union dconv *)&x)->number;
 144 }
 145
 146 static __inline__ NXSwappedFloat
 147 NXSwapFloat(NXSwappedFloat x)
 148 {
 149     return NXSwapLong(x);
 150 }
 151
 152 static __inline__ NXSwappedDouble
 153 NXSwapDouble(NXSwappedDouble x)
 154 {
 155     return NXSwapLongLong(x);
 156 }