include/sys/byteorder.h

   1 /*
   2  * CDDL HEADER START
   3  *
   4  * The contents of this file are subject to the terms of the
   5  * Common Development and Distribution License (the "License").
   6  * You may not use this file except in compliance with the License.
   7  *
   8  * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
   9  * or http://www.opensolaris.org/os/licensing.
  10  * See the License for the specific language governing permissions
  11  * and limitations under the License.
  12  *
  13  * When distributing Covered Code, include this CDDL HEADER in each
  14  * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
  15  * If applicable, add the following below this CDDL HEADER, with the
  16  * fields enclosed by brackets "[]" replaced with your own identifying
  17  * information: Portions Copyright [yyyy] [name of copyright owner]
  18  *
  19  * CDDL HEADER END
  20  */
  21
  22 /*
  23  * Copyright 2009 Sun Microsystems, Inc.  All rights reserved.
  24  * Use is subject to license terms.
  25  */
  26
  27 /*      Copyright (c) 1983, 1984, 1985, 1986, 1987, 1988, 1989 AT&T     */
  28 /*        All Rights Reserved   */
  29
  30 /*
  31  * University Copyright- Copyright (c) 1982, 1986, 1988
  32  * The Regents of the University of California
  33  * All Rights Reserved
  34  *
  35  * University Acknowledgment- Portions of this document are derived from
  36  * software developed by the University of California, Berkeley, and its
  37  * contributors.
  38  */
  39
  40 #ifndef _SYS_BYTEORDER_H
  41 #define _SYS_BYTEORDER_H
  42
  43 #include <sys/isa_defs.h>
  44 #include <sys/int_types.h>
  45
  46 #if defined(__GNUC__) && defined(_ASM_INLINES) && \
  47         (defined(__i386) || defined(__amd64))
  48 #include <asm/byteorder.h>
  49 #endif
  50
  51 #ifdef  __cplusplus
  52 extern "C" {
  53 #endif
  54
  55 /*
  56  * macros for conversion between host and (internet) network byte order
  57  */
  58
  59 #if defined(_BIG_ENDIAN) && !defined(ntohl) && !defined(__lint)
  60 /* big-endian */
  61 #define ntohl(x)        (x)
  62 #define ntohs(x)        (x)
  63 #define htonl(x)        (x)
  64 #define htons(x)        (x)
  65 #if !defined(_XPG4_2) || defined(__EXTENSIONS__)
  66 #define ntohll(x)       (x)
  67 #define htonll(x)       (x)
  68 #endif  /* !_XPG4_2 || __EXTENSIONS__ */
  69
  70 #elif !defined(ntohl) /* little-endian */
  71
  72 #ifndef _IN_PORT_T
  73 #define _IN_PORT_T
  74 typedef uint16_t in_port_t;
  75 #endif
  76
  77 #ifndef _IN_ADDR_T
  78 #define _IN_ADDR_T
  79 typedef uint32_t in_addr_t;
  80 #endif
  81
  82 #if !defined(_XPG4_2) || defined(__EXTENSIONS__) || defined(_XPG5)
  83 extern  uint32_t htonl(uint32_t);
  84 extern  uint16_t htons(uint16_t);
  85 extern  uint32_t ntohl(uint32_t);
  86 extern  uint16_t ntohs(uint16_t);
  87 #else
  88 extern  in_addr_t htonl(in_addr_t);
  89 extern  in_port_t htons(in_port_t);
  90 extern  in_addr_t ntohl(in_addr_t);
  91 extern  in_port_t ntohs(in_port_t);
  92 #endif  /* !_XPG4_2 || __EXTENSIONS__ || _XPG5 */
  93
  94 #if defined(_LP64) || defined(_LONGLONG_TYPE)
  95 #if !defined(_XPG4_2) || defined(__EXTENSIONS__)
  96 extern  uint64_t htonll(uint64_t);
  97 extern  uint64_t ntohll(uint64_t);
  98 #endif  /* !_XPG4_2 || __EXTENSIONS__ */
  99 #endif  /* _LP64 || _LONGLONG_TYPE  */
 100 #endif
 101
 102 #if !defined(_XPG4_2) || defined(__EXTENSIONS__)
 103
 104 /*
 105  * Macros to reverse byte order
 106  */
 107 #define _BSWAP_8(x)     ((x) & 0xff)
 108 #define _BSWAP_16(x)    ((_BSWAP_8(x) << 8) | _BSWAP_8((x) >> 8))
 109 #define _BSWAP_32(x)    (((uint32_t)(x) << 24) | \
 110                         (((uint32_t)(x) << 8) & 0xff0000) | \
 111                         (((uint32_t)(x) >> 8) & 0xff00) | \
 112                         ((uint32_t)(x)  >> 24))
 113 #if defined(_LP64) || defined(_LONGLONG_TYPE)
 114 #define _BSWAP_64(x)    (((uint64_t)(x) << 56) | \
 115                         (((uint64_t)(x) << 40) & 0xff000000000000ULL) | \
 116                         (((uint64_t)(x) << 24) & 0xff0000000000ULL) | \
 117                         (((uint64_t)(x) << 8)  & 0xff00000000ULL) | \
 118                         (((uint64_t)(x) >> 8)  & 0xff000000ULL) | \
 119                         (((uint64_t)(x) >> 24) & 0xff0000ULL) | \
 120                         (((uint64_t)(x) >> 40) & 0xff00ULL) | \
 121                         ((uint64_t)(x)  >> 56))
 122 #else /* no uint64_t */
 123 #define _BSWAP_64(x)    ((_BSWAP_32(x) << 32) | _BSWAP_32((x) >> 32))
 124 #endif  /* _LP64 || _LONGLONG_TYPE  */
 125
 126 /*
 127  * We do this convoluted compile time constant check because we need to
 128  * decide if we want to use the above C version to byteswap or the inline
 129  * assembly.  While modern compilers are smart enough to turn the above C
 130  * into the appropriate bswap instruction on x86, gcc 4.4.4 isn't modern
 131  * enough.  So, we want to avoid using _BSWAP_XX unconditionally.
 132  *
 133  * At the same time, we don't want to use hton* functions unconditionally
 134  * even though they are simple inline functions because that prevents us
 135  * from using BSWAP_XX in contexts where the result must be a compile time
 136  * constant.  For example, assigning a global to a constant:
 137  *
 138  *      uint32_t abc = BSWAP_32(0x12345678);
 139  *
 140  * Since the argument is a compile time constant, the byte-swapped value is
 141  * also a compile time constant.  So, in order for the compiler to be able
 142  * to calculate the constant, we must let it use the C implementation
 143  * instead of the inline assembly.
 144  *
 145  * Once we've moved to a more modern compiler, we can always use the C
 146  * version.
 147  */
 148 #if (!defined(__i386) && !defined(__amd64)) || !defined(__GNUC__)
 149 #define BSWAP_8(x)      _BSWAP_8(x)
 150 #define BSWAP_16(x)     _BSWAP_16(x)
 151 #define BSWAP_32(x)     _BSWAP_32(x)
 152 #define BSWAP_64(x)     _BSWAP_64(x)
 153 #else /* x86 */
 154 #define BSWAP_8(x)      _BSWAP_8(x)
 155 #define BSWAP_16(x)     (__builtin_constant_p(x) ? _BSWAP_16(x) : htons(x))
 156 #define BSWAP_32(x)     (__builtin_constant_p(x) ? _BSWAP_32(x) : htonl(x))
 157 #define BSWAP_64(x)     (__builtin_constant_p(x) ? _BSWAP_64(x) : htonll(x))
 158 #endif  /* !__i386 && !__amd64 */
 159
 160 #define BMASK_8(x)      ((x) & 0xff)
 161 #define BMASK_16(x)     ((x) & 0xffff)
 162 #define BMASK_32(x)     ((x) & 0xffffffff)
 163 #define BMASK_64(x)     (x)
 164
 165 /*
 166  * Macros to convert from a specific byte order to/from native byte order
 167  */
 168 #ifdef _BIG_ENDIAN
 169 #define BE_8(x)         BMASK_8(x)
 170 #define BE_16(x)        BMASK_16(x)
 171 #define BE_32(x)        BMASK_32(x)
 172 #define BE_64(x)        BMASK_64(x)
 173 #define LE_8(x)         BSWAP_8(x)
 174 #define LE_16(x)        BSWAP_16(x)
 175 #define LE_32(x)        BSWAP_32(x)
 176 #define LE_64(x)        BSWAP_64(x)
 177 #else
 178 #define LE_8(x)         BMASK_8(x)
 179 #define LE_16(x)        BMASK_16(x)
 180 #define LE_32(x)        BMASK_32(x)
 181 #define LE_64(x)        BMASK_64(x)
 182 #define BE_8(x)         BSWAP_8(x)
 183 #define BE_16(x)        BSWAP_16(x)
 184 #define BE_32(x)        BSWAP_32(x)
 185 #define BE_64(x)        BSWAP_64(x)
 186 #endif
 187
 188 /*
 189  * Macros to read unaligned values from a specific byte order to
 190  * native byte order
 191  */
 192
 193 #define BE_IN8(xa) \
 194         *((uint8_t *)(xa))
 195
 196 #if !defined(__i386) && !defined(__amd64)
 197 #define BE_IN16(xa) \
 198         (((uint16_t)BE_IN8(xa) << 8) | BE_IN8((uint8_t *)(xa) + 1))
 199
 200 #define BE_IN32(xa) \
 201         (((uint32_t)BE_IN16(xa) << 16) | BE_IN16((uint8_t *)(xa) + 2))
 202
 203 #else /* x86 */
 204 #define BE_IN16(xa) htons(*((uint16_t *)(void *)(xa)))
 205 #define BE_IN32(xa) htonl(*((uint32_t *)(void *)(xa)))
 206 #endif  /* !__i386 && !__amd64 */
 207
 208 #if (!defined(__i386) && !defined(__amd64)) || \
 209         (!defined(_LP64) && !defined(_LONGLONG_TYPE))
 210 #define BE_IN64(xa) \
 211         (((uint64_t)BE_IN32(xa) << 32) | BE_IN32((uint8_t *)(xa) + 4))
 212 #else /* x86 */
 213 #define BE_IN64(xa) htonll(*((uint64_t *)(void *)(xa)))
 214 #endif /* (!__i386 && !__amd64) || (!_LP64 && !_LONGLONG_TYPE) */
 215
 216 #define LE_IN8(xa) \
 217         *((uint8_t *)(xa))
 218
 219 #define LE_IN16(xa) \
 220         (((uint16_t)LE_IN8((uint8_t *)(xa) + 1) << 8) | LE_IN8(xa))
 221
 222 #define LE_IN32(xa) \
 223         (((uint32_t)LE_IN16((uint8_t *)(xa) + 2) << 16) | LE_IN16(xa))
 224
 225 #define LE_IN64(xa) \
 226         (((uint64_t)LE_IN32((uint8_t *)(xa) + 4) << 32) | LE_IN32(xa))
 227
 228 /*
 229  * Macros to write unaligned values from native byte order to a specific byte
 230  * order.
 231  */
 232
 233 #define BE_OUT8(xa, yv) *((uint8_t *)(xa)) = (uint8_t)(yv);
 234
 235 #define BE_OUT16(xa, yv) \
 236         BE_OUT8((uint8_t *)(xa) + 1, yv); \
 237         BE_OUT8((uint8_t *)(xa), (yv) >> 8);
 238
 239 #define BE_OUT32(xa, yv) \
 240         BE_OUT16((uint8_t *)(xa) + 2, yv); \
 241         BE_OUT16((uint8_t *)(xa), (yv) >> 16);
 242
 243 #if (!defined(__i386) && !defined(__amd64)) || \
 244         (!defined(_LP64) && !defined(_LONGLONG_TYPE))
 245 #define BE_OUT64(xa, yv) \
 246         BE_OUT32((uint8_t *)(xa) + 4, yv); \
 247         BE_OUT32((uint8_t *)(xa), (yv) >> 32);
 248 #else /* x86 with uint64_t */
 249 #define BE_OUT64(xa, yv) *((uint64_t *)(void *)(xa)) = htonll((uint64_t)(yv));
 250 #endif  /* (!__i386 && !__amd64) || (!_LP64 && !_LONGLONG_TYPE) */
 251
 252 #define LE_OUT8(xa, yv) *((uint8_t *)(xa)) = (uint8_t)(yv);
 253
 254 #define LE_OUT16(xa, yv) \
 255         LE_OUT8((uint8_t *)(xa), yv); \
 256         LE_OUT8((uint8_t *)(xa) + 1, (yv) >> 8);
 257
 258 #define LE_OUT32(xa, yv) \
 259         LE_OUT16((uint8_t *)(xa), yv); \
 260         LE_OUT16((uint8_t *)(xa) + 2, (yv) >> 16);
 261
 262 #define LE_OUT64(xa, yv) \
 263         LE_OUT32((uint8_t *)(xa), yv); \
 264         LE_OUT32((uint8_t *)(xa) + 4, (yv) >> 32);
 265
 266 #endif  /* !_XPG4_2 || __EXTENSIONS__ */
 267
 268 #ifdef  __cplusplus
 269 }
 270 #endif
 271
 272 #endif /* _SYS_BYTEORDER_H */