| /* ----------------------------------------------------------------------- * |
| * |
| * Copyright 1996-2017 The NASM Authors - All Rights Reserved |
| * See the file AUTHORS included with the NASM distribution for |
| * the specific copyright holders. |
| * |
| * Redistribution and use in source and binary forms, with or without |
| * modification, are permitted provided that the following |
| * conditions are met: |
| * |
| * * Redistributions of source code must retain the above copyright |
| * notice, this list of conditions and the following disclaimer. |
| * * Redistributions in binary form must reproduce the above |
| * copyright notice, this list of conditions and the following |
| * disclaimer in the documentation and/or other materials provided |
| * with the distribution. |
| * |
| * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND |
| * CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, |
| * INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF |
| * MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE |
| * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR |
| * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, |
| * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT |
| * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; |
| * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) |
| * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN |
| * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR |
| * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, |
| * EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
| * |
| * ----------------------------------------------------------------------- */ |
| |
| /* |
| * bytesex.h - byte order helper functions |
| * |
| * In this function, be careful about getting X86_MEMORY versus |
| * LITTLE_ENDIAN correct: X86_MEMORY also means we are allowed to |
| * do unaligned memory references, and is probabilistic. |
| */ |
| |
| #ifndef NASM_BYTEORD_H |
| #define NASM_BYTEORD_H |
| |
| #include "compiler.h" |
| |
| /* |
| * Some handy macros that will probably be of use in more than one |
| * output format: convert integers into little-endian byte packed |
| * format in memory. |
| */ |
| |
| #define WRITECHAR(p,v) \ |
| do { \ |
| uint8_t *_wc_p = (uint8_t *)(p); \ |
| *_wc_p++ = (v); \ |
| (p) = (void *)_wc_p; \ |
| } while (0) |
| |
| #if X86_MEMORY |
| |
| #define WRITESHORT(p,v) \ |
| do { \ |
| uint16_t *_ws_p = (uint16_t *)(p); \ |
| *_ws_p++ = (v); \ |
| (p) = (void *)_ws_p; \ |
| } while (0) |
| |
| #define WRITELONG(p,v) \ |
| do { \ |
| uint32_t *_wl_p = (uint32_t *)(p); \ |
| *_wl_p++ = (v); \ |
| (p) = (void *)_wl_p; \ |
| } while (0) |
| |
| #define WRITEDLONG(p,v) \ |
| do { \ |
| uint64_t *_wq_p = (uint64_t *)(p); \ |
| *_wq_p++ = (v); \ |
| (p) = (void *)_wq_p; \ |
| } while (0) |
| |
| #else /* !X86_MEMORY */ |
| |
| #define WRITESHORT(p,v) \ |
| do { \ |
| uint8_t *_ws_p = (uint8_t *)(p); \ |
| const uint16_t _ws_v = (v); \ |
| WRITECHAR(_ws_p, _ws_v); \ |
| WRITECHAR(_ws_p, _ws_v >> 8); \ |
| (p) = (void *)_ws_p; \ |
| } while (0) |
| |
| #define WRITELONG(p,v) \ |
| do { \ |
| uint8_t *_wl_p = (uint8_t *)(p); \ |
| const uint32_t _wl_v = (v); \ |
| WRITESHORT(_wl_p, _wl_v); \ |
| WRITESHORT(_wl_p, _wl_v >> 16); \ |
| (p) = (void *)_wl_p; \ |
| } while (0) |
| |
| #define WRITEDLONG(p,v) \ |
| do { \ |
| uint8_t *_wq_p = (uint8_t *)(p); \ |
| const uint64_t _wq_v = (v); \ |
| WRITELONG(_wq_p, _wq_v); \ |
| WRITELONG(_wq_p, _wq_v >> 32); \ |
| (p) = (void *)_wq_p; \ |
| } while (0) |
| |
| #endif /* X86_MEMORY */ |
| |
| /* |
| * Endian control functions which work on a single integer |
| */ |
| #ifdef WORDS_LITTLEENDIAN |
| |
| #ifndef HAVE_CPU_TO_LE16 |
| # define cpu_to_le16(v) ((uint16_t)(v)) |
| #endif |
| #ifndef HAVE_CPU_TO_LE32 |
| # define cpu_to_le32(v) ((uint32_t)(v)) |
| #endif |
| #ifndef HAVE_CPU_TO_LE64 |
| # define cpu_to_le64(v) ((uint64_t)(v)) |
| #endif |
| |
| #elif defined(WORDS_BIGENDIAN) |
| |
| #ifndef HAVE_CPU_TO_LE16 |
| static inline uint16_t cpu_to_le16(uint16_t v) |
| { |
| # ifdef HAVE___CPU_TO_LE16 |
| return __cpu_to_le16(v); |
| # elif defined(HAVE_HTOLE16) |
| return htole16(v); |
| # elif defined(HAVE___BSWAP_16) |
| return __bswap_16(v); |
| # elif defined(HAVE___BUILTIN_BSWAP16) |
| return __builtin_bswap16(v); |
| # elif defined(HAVE__BYTESWAP_USHORT) && (USHRT_MAX == 0xffffU) |
| return _byteswap_ushort(v); |
| # else |
| return (v << 8) | (v >> 8); |
| # endif |
| } |
| #endif |
| |
| #ifndef HAVE_CPU_TO_LE32 |
| static inline uint32_t cpu_to_le32(uint32_t v) |
| { |
| # ifdef HAVE___CPU_TO_LE32 |
| return __cpu_to_le32(v); |
| # elif defined(HAVE_HTOLE32) |
| return htole32(v); |
| # elif defined(HAVE___BSWAP_32) |
| return __bswap_32(v); |
| # elif defined(HAVE___BUILTIN_BSWAP32) |
| return __builtin_bswap32(v); |
| # elif defined(HAVE__BYTESWAP_ULONG) && (ULONG_MAX == 0xffffffffUL) |
| return _byteswap_ulong(v); |
| # else |
| v = ((v << 8) & 0xff00ff00 ) | |
| ((v >> 8) & 0x00ff00ff); |
| return (v << 16) | (v >> 16); |
| # endif |
| } |
| #endif |
| |
| #ifndef HAVE_CPU_TO_LE64 |
| static inline uint64_t cpu_to_le64(uint64_t v) |
| { |
| # ifdef HAVE___CPU_TO_LE64 |
| return __cpu_to_le64(v); |
| # elif defined(HAVE_HTOLE64) |
| return htole64(v); |
| # elif defined(HAVE___BSWAP_64) |
| return __bswap_64(v); |
| # elif defined(HAVE___BUILTIN_BSWAP64) |
| return __builtin_bswap64(v); |
| # elif defined(HAVE__BYTESWAP_UINT64) |
| return _byteswap_uint64(v); |
| # else |
| v = ((v << 8) & 0xff00ff00ff00ff00ull) | |
| ((v >> 8) & 0x00ff00ff00ff00ffull); |
| v = ((v << 16) & 0xffff0000ffff0000ull) | |
| ((v >> 16) & 0x0000ffff0000ffffull); |
| return (v << 32) | (v >> 32); |
| # endif |
| } |
| #endif |
| |
| #else /* not WORDS_LITTLEENDIAN or WORDS_BIGENDIAN */ |
| |
| static inline uint16_t cpu_to_le16(uint16_t v) |
| { |
| union u16 { |
| uint16_t v; |
| uint8_t c[2]; |
| } x; |
| uint8_t *cp = &x.c; |
| |
| WRITESHORT(cp, v); |
| return x.v; |
| } |
| |
| static inline uint32_t cpu_to_le32(uint32_t v) |
| { |
| union u32 { |
| uint32_t v; |
| uint8_t c[4]; |
| } x; |
| uint8_t *cp = &x.c; |
| |
| WRITELONG(cp, v); |
| return x.v; |
| } |
| |
| static inline uint64_t cpu_to_le64(uint64_t v) |
| { |
| union u64 { |
| uint64_t v; |
| uint8_t c[8]; |
| } x; |
| uint8_t *cp = &x.c; |
| |
| WRITEDLONG(cp, v); |
| return x.v; |
| } |
| |
| #endif |
| |
| #define WRITEADDR(p,v,s) \ |
| do { \ |
| switch (is_constant(s) ? (s) : 0) { \ |
| case 1: \ |
| WRITECHAR(p,v); \ |
| break; \ |
| case 2: \ |
| WRITESHORT(p,v); \ |
| break; \ |
| case 4: \ |
| WRITELONG(p,v); \ |
| break; \ |
| case 8: \ |
| WRITEDLONG(p,v); \ |
| break; \ |
| default: \ |
| { \ |
| const uint64_t _wa_v = cpu_to_le64(v); \ |
| const size_t _wa_s = (s); \ |
| uint8_t * const _wa_p = (uint8_t *)(p); \ |
| memcpy(_wa_p, &_wa_v, _wa_s); \ |
| (p) = (void *)(_wa_p + _wa_s); \ |
| } \ |
| break; \ |
| } \ |
| } while (0) |
| |
| #endif /* NASM_BYTESEX_H */ |
