LCOV - code coverage report
Current view: top level - usr/include/sys - endian.h (source / functions) Hit Total Coverage
Test: cov.info Lines: 3 6 50.0 %
Date: 2015-08-15 Functions: 1 2 50.0 %

          Line data    Source code
       1             : /*-
       2             :  * Copyright (c) 2002 Thomas Moestl <tmm@FreeBSD.org>
       3             :  * All rights reserved.
       4             :  *
       5             :  * Redistribution and use in source and binary forms, with or without
       6             :  * modification, are permitted provided that the following conditions
       7             :  * are met:
       8             :  * 1. Redistributions of source code must retain the above copyright
       9             :  *    notice, this list of conditions and the following disclaimer.
      10             :  * 2. Redistributions in binary form must reproduce the above copyright
      11             :  *    notice, this list of conditions and the following disclaimer in the
      12             :  *    documentation and/or other materials provided with the distribution.
      13             :  *
      14             :  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
      15             :  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
      16             :  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
      17             :  * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
      18             :  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
      19             :  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
      20             :  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
      21             :  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
      22             :  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
      23             :  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
      24             :  * SUCH DAMAGE.
      25             :  *
      26             :  * $FreeBSD: head/sys/sys/endian.h 208331 2010-05-20 06:16:13Z phk $
      27             :  */
      28             : 
      29             : #ifndef _SYS_ENDIAN_H_
      30             : #define _SYS_ENDIAN_H_
      31             : 
      32             : #include <sys/cdefs.h>
      33             : #include <sys/_types.h>
      34             : #include <machine/endian.h>
      35             : 
      36             : #ifndef _UINT8_T_DECLARED
      37             : typedef __uint8_t       uint8_t;
      38             : #define _UINT8_T_DECLARED
      39             : #endif
      40             :  
      41             : #ifndef _UINT16_T_DECLARED
      42             : typedef __uint16_t      uint16_t;
      43             : #define _UINT16_T_DECLARED
      44             : #endif
      45             :  
      46             : #ifndef _UINT32_T_DECLARED
      47             : typedef __uint32_t      uint32_t;
      48             : #define _UINT32_T_DECLARED
      49             : #endif
      50             :  
      51             : #ifndef _UINT64_T_DECLARED
      52             : typedef __uint64_t      uint64_t;
      53             : #define _UINT64_T_DECLARED
      54             : #endif
      55             :  
      56             : /*
      57             :  * General byte order swapping functions.
      58             :  */
      59             : #define bswap16(x)      __bswap16(x)
      60             : #define bswap32(x)      __bswap32(x)
      61             : #define bswap64(x)      __bswap64(x)
      62             : 
      63             : /*
      64             :  * Host to big endian, host to little endian, big endian to host, and little
      65             :  * endian to host byte order functions as detailed in byteorder(9).
      66             :  */
      67             : #if _BYTE_ORDER == _LITTLE_ENDIAN
      68             : #define htobe16(x)      bswap16((x))
      69             : #define htobe32(x)      bswap32((x))
      70             : #define htobe64(x)      bswap64((x))
      71             : #define htole16(x)      ((uint16_t)(x))
      72             : #define htole32(x)      ((uint32_t)(x))
      73             : #define htole64(x)      ((uint64_t)(x))
      74             : 
      75             : #define be16toh(x)      bswap16((x))
      76             : #define be32toh(x)      bswap32((x))
      77             : #define be64toh(x)      bswap64((x))
      78             : #define le16toh(x)      ((uint16_t)(x))
      79             : #define le32toh(x)      ((uint32_t)(x))
      80             : #define le64toh(x)      ((uint64_t)(x))
      81             : #else /* _BYTE_ORDER != _LITTLE_ENDIAN */
      82             : #define htobe16(x)      ((uint16_t)(x))
      83             : #define htobe32(x)      ((uint32_t)(x))
      84             : #define htobe64(x)      ((uint64_t)(x))
      85             : #define htole16(x)      bswap16((x))
      86             : #define htole32(x)      bswap32((x))
      87             : #define htole64(x)      bswap64((x))
      88             : 
      89             : #define be16toh(x)      ((uint16_t)(x))
      90             : #define be32toh(x)      ((uint32_t)(x))
      91             : #define be64toh(x)      ((uint64_t)(x))
      92             : #define le16toh(x)      bswap16((x))
      93             : #define le32toh(x)      bswap32((x))
      94             : #define le64toh(x)      bswap64((x))
      95             : #endif /* _BYTE_ORDER == _LITTLE_ENDIAN */
      96             : 
      97             : /* Alignment-agnostic encode/decode bytestream to/from little/big endian. */
      98             : 
      99             : static __inline uint16_t
     100             : be16dec(const void *pp)
     101             : {
     102             :         uint8_t const *p = (uint8_t const *)pp;
     103             : 
     104             :         return ((p[0] << 8) | p[1]);
     105             : }
     106             : 
     107             : static __inline uint32_t
     108           0 : be32dec(const void *pp)
     109             : {
     110           0 :         uint8_t const *p = (uint8_t const *)pp;
     111             : 
     112           0 :         return (((unsigned)p[0] << 24) | (p[1] << 16) | (p[2] << 8) | p[3]);
     113             : }
     114             : 
     115             : static __inline uint64_t
     116             : be64dec(const void *pp)
     117             : {
     118             :         uint8_t const *p = (uint8_t const *)pp;
     119             : 
     120             :         return (((uint64_t)be32dec(p) << 32) | be32dec(p + 4));
     121             : }
     122             : 
     123             : static __inline uint16_t
     124             : le16dec(const void *pp)
     125             : {
     126             :         uint8_t const *p = (uint8_t const *)pp;
     127             : 
     128             :         return ((p[1] << 8) | p[0]);
     129             : }
     130             : 
     131             : static __inline uint32_t
     132         438 : le32dec(const void *pp)
     133             : {
     134         438 :         uint8_t const *p = (uint8_t const *)pp;
     135             : 
     136         438 :         return (((unsigned)p[3] << 24) | (p[2] << 16) | (p[1] << 8) | p[0]);
     137             : }
     138             : 
     139             : static __inline uint64_t
     140             : le64dec(const void *pp)
     141             : {
     142             :         uint8_t const *p = (uint8_t const *)pp;
     143             : 
     144             :         return (((uint64_t)le32dec(p + 4) << 32) | le32dec(p));
     145             : }
     146             : 
     147             : static __inline void
     148             : be16enc(void *pp, uint16_t u)
     149             : {
     150             :         uint8_t *p = (uint8_t *)pp;
     151             : 
     152             :         p[0] = (u >> 8) & 0xff;
     153             :         p[1] = u & 0xff;
     154             : }
     155             : 
     156             : static __inline void
     157             : be32enc(void *pp, uint32_t u)
     158             : {
     159             :         uint8_t *p = (uint8_t *)pp;
     160             : 
     161             :         p[0] = (u >> 24) & 0xff;
     162             :         p[1] = (u >> 16) & 0xff;
     163             :         p[2] = (u >> 8) & 0xff;
     164             :         p[3] = u & 0xff;
     165             : }
     166             : 
     167             : static __inline void
     168             : be64enc(void *pp, uint64_t u)
     169             : {
     170             :         uint8_t *p = (uint8_t *)pp;
     171             : 
     172             :         be32enc(p, (uint32_t)(u >> 32));
     173             :         be32enc(p + 4, (uint32_t)(u & 0xffffffffU));
     174             : }
     175             : 
     176             : static __inline void
     177             : le16enc(void *pp, uint16_t u)
     178             : {
     179             :         uint8_t *p = (uint8_t *)pp;
     180             : 
     181             :         p[0] = u & 0xff;
     182             :         p[1] = (u >> 8) & 0xff;
     183             : }
     184             : 
     185             : static __inline void
     186             : le32enc(void *pp, uint32_t u)
     187             : {
     188             :         uint8_t *p = (uint8_t *)pp;
     189             : 
     190             :         p[0] = u & 0xff;
     191             :         p[1] = (u >> 8) & 0xff;
     192             :         p[2] = (u >> 16) & 0xff;
     193             :         p[3] = (u >> 24) & 0xff;
     194             : }
     195             : 
     196             : static __inline void
     197             : le64enc(void *pp, uint64_t u)
     198             : {
     199             :         uint8_t *p = (uint8_t *)pp;
     200             : 
     201             :         le32enc(p, (uint32_t)(u & 0xffffffffU));
     202             :         le32enc(p + 4, (uint32_t)(u >> 32));
     203             : }
     204             : 
     205             : #endif  /* _SYS_ENDIAN_H_ */

Generated by: LCOV version 1.10