Line data    Source code

       1             : /*   SPDX-License-Identifier: BSD-3-Clause
       2             :  *   Copyright (C) 2016 Intel Corporation.
       3             :  *   All rights reserved.
       4             :  */
       5             : 
       6             : /**
       7             :  * \file
       8             :  * Endian conversion functions
       9             :  */
      10             : 
      11             : #ifndef SPDK_ENDIAN_H
      12             : #define SPDK_ENDIAN_H
      13             : 
      14             : #include "spdk/stdinc.h"
      15             : 
      16             : #ifdef __cplusplus
      17             : extern "C" {
      18             : #endif
      19             : 
      20             : static inline uint16_t
      21        5185 : from_be16(const void *ptr)
      22             : {
      23        5185 :         const uint8_t *tmp = (const uint8_t *)ptr;
      24        5185 :         return (((uint16_t)tmp[0] << 8) | tmp[1]);
      25             : }
      26             : 
      27             : static inline void
      28        5033 : to_be16(void *out, uint16_t in)
      29             : {
      30        5033 :         uint8_t *tmp = (uint8_t *)out;
      31        5033 :         tmp[0] = (in >> 8) & 0xFF;
      32        5033 :         tmp[1] = in & 0xFF;
      33        5033 : }
      34             : 
      35             : static inline uint32_t
      36        1971 : from_be32(const void *ptr)
      37             : {
      38        1971 :         const uint8_t *tmp = (const uint8_t *)ptr;
      39        1971 :         return (((uint32_t)tmp[0] << 24) |
      40        1971 :                 ((uint32_t)tmp[1] << 16) |
      41        1971 :                 ((uint32_t)tmp[2] << 8) |
      42        1971 :                 ((uint32_t)tmp[3]));
      43             : }
      44             : 
      45             : static inline void
      46        2972 : to_be32(void *out, uint32_t in)
      47             : {
      48        2972 :         uint8_t *tmp = (uint8_t *)out;
      49        2972 :         tmp[0] = (in >> 24) & 0xFF;
      50        2972 :         tmp[1] = (in >> 16) & 0xFF;
      51        2972 :         tmp[2] = (in >> 8) & 0xFF;
      52        2972 :         tmp[3] = in & 0xFF;
      53        2972 : }
      54             : 
      55             : static inline uint64_t
      56         797 : from_be64(const void *ptr)
      57             : {
      58         797 :         const uint8_t *tmp = (const uint8_t *)ptr;
      59         797 :         return (((uint64_t)tmp[0] << 56) |
      60         797 :                 ((uint64_t)tmp[1] << 48) |
      61         797 :                 ((uint64_t)tmp[2] << 40) |
      62         797 :                 ((uint64_t)tmp[3] << 32) |
      63         797 :                 ((uint64_t)tmp[4] << 24) |
      64         797 :                 ((uint64_t)tmp[5] << 16) |
      65         797 :                 ((uint64_t)tmp[6] << 8) |
      66         797 :                 ((uint64_t)tmp[7]));
      67             : }
      68             : 
      69             : static inline void
      70        1498 : to_be64(void *out, uint64_t in)
      71             : {
      72        1498 :         uint8_t *tmp = (uint8_t *)out;
      73        1498 :         tmp[0] = (in >> 56) & 0xFF;
      74        1498 :         tmp[1] = (in >> 48) & 0xFF;
      75        1498 :         tmp[2] = (in >> 40) & 0xFF;
      76        1498 :         tmp[3] = (in >> 32) & 0xFF;
      77        1498 :         tmp[4] = (in >> 24) & 0xFF;
      78        1498 :         tmp[5] = (in >> 16) & 0xFF;
      79        1498 :         tmp[6] = (in >> 8) & 0xFF;
      80        1498 :         tmp[7] = in & 0xFF;
      81        1498 : }
      82             : 
      83             : static inline uint16_t
      84          33 : from_le16(const void *ptr)
      85             : {
      86          33 :         const uint8_t *tmp = (const uint8_t *)ptr;
      87          33 :         return (((uint16_t)tmp[1] << 8) | tmp[0]);
      88             : }
      89             : 
      90             : static inline void
      91             : to_le16(void *out, uint16_t in)
      92             : {
      93             :         uint8_t *tmp = (uint8_t *)out;
      94             :         tmp[1] = (in >> 8) & 0xFF;
      95             :         tmp[0] = in & 0xFF;
      96             : }
      97             : 
      98             : static inline uint32_t
      99          92 : from_le32(const void *ptr)
     100             : {
     101          92 :         const uint8_t *tmp = (const uint8_t *)ptr;
     102          92 :         return (((uint32_t)tmp[3] << 24) |
     103          92 :                 ((uint32_t)tmp[2] << 16) |
     104          92 :                 ((uint32_t)tmp[1] << 8) |
     105          92 :                 ((uint32_t)tmp[0]));
     106             : }
     107             : 
     108             : static inline void
     109          39 : to_le32(void *out, uint32_t in)
     110             : {
     111          39 :         uint8_t *tmp = (uint8_t *)out;
     112          39 :         tmp[3] = (in >> 24) & 0xFF;
     113          39 :         tmp[2] = (in >> 16) & 0xFF;
     114          39 :         tmp[1] = (in >> 8) & 0xFF;
     115          39 :         tmp[0] = in & 0xFF;
     116          39 : }
     117             : 
     118             : static inline uint64_t
     119          51 : from_le64(const void *ptr)
     120             : {
     121          51 :         const uint8_t *tmp = (const uint8_t *)ptr;
     122          51 :         return (((uint64_t)tmp[7] << 56) |
     123          51 :                 ((uint64_t)tmp[6] << 48) |
     124          51 :                 ((uint64_t)tmp[5] << 40) |
     125          51 :                 ((uint64_t)tmp[4] << 32) |
     126          51 :                 ((uint64_t)tmp[3] << 24) |
     127          51 :                 ((uint64_t)tmp[2] << 16) |
     128          51 :                 ((uint64_t)tmp[1] << 8) |
     129          51 :                 ((uint64_t)tmp[0]));
     130             : }
     131             : 
     132             : static inline void
     133          22 : to_le64(void *out, uint64_t in)
     134             : {
     135          22 :         uint8_t *tmp = (uint8_t *)out;
     136          22 :         tmp[7] = (in >> 56) & 0xFF;
     137          22 :         tmp[6] = (in >> 48) & 0xFF;
     138          22 :         tmp[5] = (in >> 40) & 0xFF;
     139          22 :         tmp[4] = (in >> 32) & 0xFF;
     140          22 :         tmp[3] = (in >> 24) & 0xFF;
     141          22 :         tmp[2] = (in >> 16) & 0xFF;
     142          22 :         tmp[1] = (in >> 8) & 0xFF;
     143          22 :         tmp[0] = in & 0xFF;
     144          22 : }
     145             : 
     146             : #ifdef __cplusplus
     147             : }
     148             : #endif
     149             : 
     150             : #endif