1 /* 2 * IDI,NTNU 3 * 4 * CDDL HEADER START 5 * 6 * The contents of this file are subject to the terms of the 7 * Common Development and Distribution License (the "License"). 8 * You may not use this file except in compliance with the License. 9 * 10 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE 11 * or http://opensource.org/licenses/CDDL-1.0. 12 * See the License for the specific language governing permissions 13 * and limitations under the License. 14 * 15 * When distributing Covered Code, include this CDDL HEADER in each 16 * file and include the License file at usr/src/OPENSOLARIS.LICENSE. 17 * If applicable, add the following below this CDDL HEADER, with the 18 * fields enclosed by brackets "[]" replaced with your own identifying 19 * information: Portions Copyright [yyyy] [name of copyright owner] 20 * 21 * CDDL HEADER END 22 * 23 * Copyright (C) 2009, 2010, Jorn Amundsen <jorn.amundsen@ntnu.no> 24 * 25 * C header file to determine compile machine byte order. Take care when cross 26 * compiling. 27 * 28 * $Id: byteorder.h 517 2013-02-17 20:34:39Z joern $ 29 */ 30 /* 31 * Portions copyright (c) 2013, Saso Kiselkov, All rights reserved 32 */ 33 34 #if !defined(BYTEORDER_INCLUDED) 35 36 #if defined(__linux) 37 #include <endian.h> 38 #else 39 #include <sys/param.h> 40 #endif 41 42 #if defined(__BYTE_ORDER) 43 #if (__BYTE_ORDER == __BIG_ENDIAN) 44 #define MACHINE_IS_BIG_ENDIAN 45 #elif (__BYTE_ORDER == __LITTLE_ENDIAN) 46 #define MACHINE_IS_LITTLE_ENDIAN 47 #endif 48 #elif defined(BYTE_ORDER) 49 #if (BYTE_ORDER == BIG_ENDIAN) 50 #define MACHINE_IS_BIG_ENDIAN 51 #elif (BYTE_ORDER == LITTLE_ENDIAN) 52 #define MACHINE_IS_LITTLE_ENDIAN 53 #endif 54 #endif /* __BYTE_ORDER || BYTE_ORDER */ 55 56 #if !defined(MACHINE_IS_BIG_ENDIAN) && !defined(MACHINE_IS_LITTLE_ENDIAN) 57 #if defined(_BIG_ENDIAN) || defined(_MIPSEB) 58 #define MACHINE_IS_BIG_ENDIAN 59 #endif 60 #if defined(_LITTLE_ENDIAN) || defined(_MIPSEL) 61 #define MACHINE_IS_LITTLE_ENDIAN 62 #endif 63 #endif /* !MACHINE_IS_BIG_ENDIAN && !MACHINE_IS_LITTLE_ENDIAN */ 64 65 #if !defined(MACHINE_IS_BIG_ENDIAN) && !defined(MACHINE_IS_LITTLE_ENDIAN) 66 #error unknown machine byte sex 67 #endif 68 69 #define BYTEORDER_INCLUDED 70 71 #if defined(MACHINE_IS_BIG_ENDIAN) 72 /* 73 * Byte swapping macros for big endian architectures and compilers, 74 * add as appropriate for other architectures and/or compilers. 75 * 76 * ld_swap64(src,dst) : uint64_t dst = *(src) 77 * st_swap64(src,dst) : *(dst) = uint64_t src 78 */ 79 80 #if defined(__PPC__) || defined(_ARCH_PPC) 81 82 #if defined(__64BIT__) 83 #if defined(_ARCH_PWR7) 84 #define aix_ld_swap64(s64, d64)\ 85 __asm__("ldbrx %0,0,%1" : "=r"(d64) : "r"(s64)) 86 #define aix_st_swap64(s64, d64)\ 87 __asm__ volatile("stdbrx %1,0,%0" : : "r"(d64), "r"(s64)) 88 #else 89 #define aix_ld_swap64(s64, d64)\ 90 {\ 91 uint64_t *s4, h;\ 92 \ 93 __asm__("addi %0,%3,4;lwbrx %1,0,%3;lwbrx %2,0,%0;rldimi %1,%2,32,0"\ 94 : "+r"(s4), "=r"(d64), "=r"(h) : "b"(s64));\ 95 } 96 97 #define aix_st_swap64(s64, d64)\ 98 {\ 99 uint64_t *s4, h;\ 100 \ 101 h = (s64) >> 32;\ 102 \ 103 __asm__ volatile("addi %0,%3,4;stwbrx %1,0,%3;stwbrx %2,0,%0"\ 104 : "+r"(s4) : "r"(s64), "r"(h), "b"(d64));\ 105 } 106 #endif /* 64BIT && PWR7 */ 107 #else 108 #define aix_ld_swap64(s64, d64)\ 109 {\ 110 uint32_t *s4, h, l;\ 111 \ 112 __asm__("addi %0,%3,4;lwbrx %1,0,%3;lwbrx %2,0,%0"\ 113 : "+r"(s4), "=r"(l), "=r"(h) : "b"(s64));\ 114 \ 115 d64 = ((uint64_t)h<<32) | l;\ 116 } 117 118 #define aix_st_swap64(s64, d64)\ 119 {\ 120 uint32_t *s4, h, l;\ 121 \ 122 l = (s64) & 0xfffffffful, h = (s64) >> 32;\ 123 \ 124 __asm__ volatile("addi %0,%3,4;stwbrx %1,0,%3;stwbrx %2,0,%0"\ 125 : "+r"(s4) : "r"(l), "r"(h), "b"(d64));\ 126 } 127 #endif /* __64BIT__ */ 128 #define aix_ld_swap32(s32, d32)\ 129 __asm__("lwbrx %0,0,%1" : "=r"(d32) : "r"(s32)) 130 #define aix_st_swap32(s32, d32)\ 131 __asm__ volatile("stwbrx %1,0,%0" : : "r"(d32), "r"(s32)) 132 #define ld_swap32(s, d) aix_ld_swap32(s, d) 133 #define st_swap32(s, d) aix_st_swap32(s, d) 134 #define ld_swap64(s, d) aix_ld_swap64(s, d) 135 #define st_swap64(s, d) aix_st_swap64(s, d) 136 #endif /* __PPC__ || _ARCH_PPC */ 137 138 #if defined(__sparc) 139 #if !defined(__arch64__) && !defined(__sparcv8) && defined(__sparcv9) 140 #define __arch64__ 141 #endif 142 #if defined(__GNUC__) || (defined(__SUNPRO_C) && __SUNPRO_C > 0x590) 143 /* need Sun Studio C 5.10 and above for GNU inline assembly */ 144 #if defined(__arch64__) 145 #define sparc_ld_swap64(s64, d64)\ 146 __asm__("ldxa [%1]0x88,%0" : "=r"(d64) : "r"(s64)) 147 #define sparc_st_swap64(s64, d64)\ 148 __asm__ volatile("stxa %0,[%1]0x88" : : "r"(s64), "r"(d64)) 149 #define st_swap64(s, d) sparc_st_swap64(s, d) 150 #else 151 #define sparc_ld_swap64(s64, d64)\ 152 {\ 153 uint32_t *s4, h, l;\ 154 \ 155 __asm__("add %3,4,%0\n\tlda [%3]0x88,%1\n\tlda [%0]0x88,%2"\ 156 : "+r"(s4), "=r"(l), "=r"(h) : "r"(s64));\ 157 \ 158 d64 = ((uint64_t)h<<32) | l;\ 159 } 160 #define sparc_st_swap64(s64, d64)\ 161 {\ 162 uint32_t *s4, h, l;\ 163 \ 164 l = (s64) & 0xfffffffful, h = (s64) >> 32;\ 165 \ 166 __asm__ volatile("add %3,4,%0\n\tsta %1,[%3]0x88\n\tsta %2,[%0]0x88"\ 167 : "+r"(s4) : "r"(l), "r"(h), "r"(d64));\ 168 } 169 #endif /* sparc64 */ 170 #define sparc_ld_swap32(s32, d32)\ 171 __asm__("lda [%1]0x88,%0" : "=r"(d32) : "r"(s32)) 172 #define sparc_st_swap32(s32, d32)\ 173 __asm__ volatile("sta %0,[%1]0x88" : : "r"(s32), "r"(d32)) 174 #define ld_swap32(s, d) sparc_ld_swap32(s, d) 175 #define st_swap32(s, d) sparc_st_swap32(s, d) 176 #define ld_swap64(s, d) sparc_ld_swap64(s, d) 177 #define st_swap64(s, d) sparc_st_swap64(s, d) 178 #endif /* GCC || Sun Studio C > 5.9 */ 179 #endif /* sparc */ 180 181 /* GCC fallback */ 182 #if ((__GNUC__ >= 4) || defined(__PGIC__)) && !defined(ld_swap32) 183 #define ld_swap32(s, d) (d = __builtin_bswap32(*(s))) 184 #define st_swap32(s, d) (*(d) = __builtin_bswap32(s)) 185 #endif /* GCC4/PGIC && !swap32 */ 186 #if ((__GNUC__ >= 4) || defined(__PGIC__)) && !defined(ld_swap64) 187 #define ld_swap64(s, d) (d = __builtin_bswap64(*(s))) 188 #define st_swap64(s, d) (*(d) = __builtin_bswap64(s)) 189 #endif /* GCC4/PGIC && !swap64 */ 190 191 /* generic fallback */ 192 #if !defined(ld_swap32) 193 #define ld_swap32(s, d) (d = \ 194 (*(s)>>24)|(*(s)>>8&0xff00)|(*(s)<<8&0xff0000)|(*(s)<<24)) 195 #define st_swap32(s, d) (*(d) = \ 196 ((s)>>24)|((s)>>8&0xff00)|((s)<<8&0xff0000)|((s)<<24)) 197 #endif 198 #if !defined(ld_swap64) 199 #define ld_swap64(s, d) (d = (*(s)>>56)|(*(s)>>40&0xff00)|(*(s)>>24&0xff0000)|\ 200 (*(s)>>8&0xff000000)|(*(s)&0xff000000)<<8|(*(s)&0xff0000)<<24|\ 201 (*(s)&0xff00)<<40|*(s)<<56) 202 #define st_swap64(s, d) (*(d) = ((s)>>56)|((s)>>40&0xff00)|((s)>>24&0xff0000)|\ 203 ((s)>>8&0xff000000)|((s)&0xff000000)<<8|((s)&0xff0000)<<24|\ 204 ((s)&0xff00)<<40|(s)<<56) 205 #endif 206 207 #endif /* MACHINE_IS_BIG_ENDIAN */ 208 209 210 #if defined(MACHINE_IS_LITTLE_ENDIAN) 211 /* replace swaps with simple assignments on little endian systems */ 212 #undef ld_swap32 213 #undef st_swap32 214 #define ld_swap32(s, d) (d = *(s)) 215 #define st_swap32(s, d) (*(d) = s) 216 #undef ld_swap64 217 #undef st_swap64 218 #define ld_swap64(s, d) (d = *(s)) 219 #define st_swap64(s, d) (*(d) = s) 220 #endif /* MACHINE_IS_LITTLE_ENDIAN */ 221 222 #endif /* BYTEORDER_INCLUDED */