LCOV - code coverage report
Current view: top level - vppinfra - byte_order.h (source / functions) Hit Total Coverage
Test: coverage-filtered.info Lines: 19 21 90.5 %
Date: 2023-10-26 01:39:38 Functions: 28 50 56.0 %

          Line data    Source code
       1             : /*
       2             :  * Copyright (c) 2015 Cisco and/or its affiliates.
       3             :  * Licensed under the Apache License, Version 2.0 (the "License");
       4             :  * you may not use this file except in compliance with the License.
       5             :  * You may obtain a copy of the License at:
       6             :  *
       7             :  *     http://www.apache.org/licenses/LICENSE-2.0
       8             :  *
       9             :  * Unless required by applicable law or agreed to in writing, software
      10             :  * distributed under the License is distributed on an "AS IS" BASIS,
      11             :  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
      12             :  * See the License for the specific language governing permissions and
      13             :  * limitations under the License.
      14             :  */
      15             : /*
      16             :   Copyright (c) 2004 Eliot Dresselhaus
      17             : 
      18             :   Permission is hereby granted, free of charge, to any person obtaining
      19             :   a copy of this software and associated documentation files (the
      20             :   "Software"), to deal in the Software without restriction, including
      21             :   without limitation the rights to use, copy, modify, merge, publish,
      22             :   distribute, sublicense, and/or sell copies of the Software, and to
      23             :   permit persons to whom the Software is furnished to do so, subject to
      24             :   the following conditions:
      25             : 
      26             :   The above copyright notice and this permission notice shall be
      27             :   included in all copies or substantial portions of the Software.
      28             : 
      29             :   THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
      30             :   EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
      31             :   MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
      32             :   NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
      33             :   LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
      34             :   OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
      35             :   WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
      36             : */
      37             : 
      38             : #ifndef included_clib_byte_order_h
      39             : #define included_clib_byte_order_h
      40             : 
      41             : #include <vppinfra/clib.h>
      42             : 
      43             : #if (__BYTE_ORDER__)==( __ORDER_LITTLE_ENDIAN__)
      44             : #define CLIB_ARCH_IS_BIG_ENDIAN (0)
      45             : #define CLIB_ARCH_IS_LITTLE_ENDIAN (1)
      46             : #else
      47             : /* Default is big endian. */
      48             : #define CLIB_ARCH_IS_BIG_ENDIAN (1)
      49             : #define CLIB_ARCH_IS_LITTLE_ENDIAN (0)
      50             : #endif
      51             : 
      52             : /* Big/little endian. */
      53             : #define clib_arch_is_big_endian    CLIB_ARCH_IS_BIG_ENDIAN
      54             : #define clib_arch_is_little_endian CLIB_ARCH_IS_LITTLE_ENDIAN
      55             : 
      56             : always_inline u16
      57   450173197 : clib_byte_swap_u16 (u16 x)
      58             : {
      59   450173197 :   return __builtin_bswap16 (x);
      60             : }
      61             : 
      62             : always_inline i16
      63          46 : clib_byte_swap_i16 (i16 x)
      64             : {
      65          46 :   return clib_byte_swap_u16 (x);
      66             : }
      67             : 
      68             : always_inline u32
      69   103623902 : clib_byte_swap_u32 (u32 x)
      70             : {
      71   103623902 :   return __builtin_bswap32 (x);
      72             : }
      73             : 
      74             : always_inline i32
      75        4208 : clib_byte_swap_i32 (i32 x)
      76             : {
      77        4208 :   return clib_byte_swap_u32 (x);
      78             : }
      79             : 
      80             : always_inline u64
      81    12322818 : clib_byte_swap_u64 (u64 x)
      82             : {
      83    12322818 :   return __builtin_bswap64 (x);
      84             : }
      85             : 
      86             : always_inline i64
      87             : clib_byte_swap_i64 (i64 x)
      88             : {
      89             :   return clib_byte_swap_u64 (x);
      90             : }
      91             : 
      92             : #define _(sex,type)                                             \
      93             : /* HOST -> SEX */                                            \
      94             : always_inline type                                              \
      95             : clib_host_to_##sex##_##type (type x)                            \
      96             : {                                                               \
      97             :   if (! clib_arch_is_##sex##_endian)                            \
      98             :     x = clib_byte_swap_##type (x);                              \
      99             :   return x;                                                     \
     100             : }                                                               \
     101             :                                                                 \
     102             : always_inline type                                              \
     103             : clib_host_to_##sex##_mem_##type (type * x)                      \
     104             : {                                                               \
     105             :   type v = x[0];                                                \
     106             :   return clib_host_to_##sex##_##type (v);                       \
     107             : }                                                               \
     108             :                                                                 \
     109             : always_inline type                                              \
     110             : clib_host_to_##sex##_unaligned_mem_##type (type * x)            \
     111             : {                                                               \
     112             :   type v = clib_mem_unaligned (x, type);                        \
     113             :   return clib_host_to_##sex##_##type (v);                       \
     114             : }                                                               \
     115             :                                                                 \
     116             : /* SEX -> HOST */                                            \
     117             : always_inline type                                              \
     118             : clib_##sex##_to_host_##type (type x)                            \
     119             : { return clib_host_to_##sex##_##type (x); }                     \
     120             :                                                                 \
     121             : always_inline type                                              \
     122             : clib_##sex##_to_host_mem_##type (type * x)                      \
     123             : { return clib_host_to_##sex##_mem_##type (x); }                 \
     124             :                                                                 \
     125             : always_inline type                                              \
     126             : clib_##sex##_to_host_unaligned_mem_##type (type * x)            \
     127             : { return clib_host_to_##sex##_unaligned_mem_##type (x); }
     128             : 
     129             : #ifndef __cplusplus
     130     2673270 : _(little, u16)
     131           0 : _(little, u32)
     132           0 : _(little, u64)
     133             : _(little, i16)
     134             : _(little, i32)
     135             : _(little, i64)
     136   954872875 : _(big, u16) _(big, u32) _(big, u64) _(big, i16) _(big, i32) _(big, i64)
     137             : #endif
     138             : #undef _
     139             : /* Network "net" alias for "big". */
     140             : #define _(type)                                         \
     141             : always_inline type                                      \
     142             : clib_net_to_host_##type (type x)                        \
     143             : { return clib_big_to_host_##type (x); }                 \
     144             :                                                         \
     145             : always_inline type                                      \
     146             : clib_net_to_host_mem_##type (type * x)                  \
     147             : { return clib_big_to_host_mem_##type (x); }             \
     148             :                                                         \
     149             : always_inline type                                      \
     150             : clib_net_to_host_unaligned_mem_##type (type * x)        \
     151             : { return clib_big_to_host_unaligned_mem_##type (x); }   \
     152             :                                                         \
     153             : always_inline type                                      \
     154             : clib_host_to_net_##type (type x)                        \
     155             : { return clib_host_to_big_##type (x); }                 \
     156             :                                                         \
     157             : always_inline type                                      \
     158             : clib_host_to_net_mem_##type (type * x)                  \
     159             : { return clib_host_to_big_mem_##type (x); }             \
     160             :                                                         \
     161             : always_inline type                                      \
     162             : clib_host_to_net_unaligned_mem_##type (type * x)        \
     163             : { return clib_host_to_big_unaligned_mem_##type (x); }
     164             : #ifndef __cplusplus
     165   450173143 :   _(u16);
     166          46 : _(i16);
     167   103619678 : _(u32);
     168        4208 : _(i32);
     169    12322818 : _(u64);
     170             : _(i64);
     171             : #endif
     172             : 
     173             : #undef _
     174             : 
     175             : /* Dummy endian swap functions for IEEE floating-point numbers */
     176             : /* *INDENT-OFF* */
     177          14 : always_inline f64 clib_net_to_host_f64 (f64 x) { return x; }
     178        5925 : always_inline f64 clib_host_to_net_f64 (f64 x) { return x; }
     179             : always_inline f32 clib_net_to_host_f32 (f32 x) { return x; }
     180             : always_inline f32 clib_host_to_net_f32 (f32 x) { return x; }
     181             : /* *INDENT-ON* */
     182             : 
     183             : #endif /* included_clib_byte_order_h */
     184             : 
     185             : /*
     186             :  * fd.io coding-style-patch-verification: ON
     187             :  *
     188             :  * Local Variables:
     189             :  * eval: (c-set-style "gnu")
     190             :  * End:
     191             :  */

Generated by: LCOV version 1.14