EESAST
/
THUAI6
Not watched
1
0
Fork 0
Code
Releases 3 Wiki evaluate Activity
Issues 0 Pull Requests 0 Datasets Model Cloudbrain HPC
You can not select more than 25 topics Topics must start with a chinese character,a letter or number, can include dashes ('-') and can be up to 35 characters long.
Tree: 217d87aeed
Branches Tags
${ item.name }
Create branch ${ searchTerm }
from '217d87aeed'
${ noResults }
THUAI6/CAPI/cpp/grpc/include/absl/base/internal/endian.h

473 lines
12 kB
Raw Blame History 

  1. // Copyright 2017 The Abseil Authors.

  2. //

  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. //      https://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. #ifndef ABSL_BASE_INTERNAL_ENDIAN_H_

  17. #define ABSL_BASE_INTERNAL_ENDIAN_H_

  18. 

  19. #include <cstdint>

  20. #include <cstdlib>

  21. 

  22. #include "absl/base/casts.h"

  23. #include "absl/base/config.h"

  24. #include "absl/base/internal/unaligned_access.h"

  25. #include "absl/base/port.h"

  26. 

  27. namespace absl

  28. {

  29.     ABSL_NAMESPACE_BEGIN

  30. 

  31.     inline uint64_t gbswap_64(uint64_t host_int)

  32.     {

  33. #if ABSL_HAVE_BUILTIN(__builtin_bswap64) || defined(__GNUC__)

  34.         return __builtin_bswap64(host_int);

  35. #elif defined(_MSC_VER)

  36.         return _byteswap_uint64(host_int);

  37. #else

  38.         return (((host_int & uint64_t{0xFF}) << 56) | ((host_int & uint64_t{0xFF00}) << 40) | ((host_int & uint64_t{0xFF0000}) << 24) | ((host_int & uint64_t{0xFF000000}) << 8) | ((host_int & uint64_t{0xFF00000000}) >> 8) | ((host_int & uint64_t{0xFF0000000000}) >> 24) | ((host_int & uint64_t{0xFF000000000000}) >> 40) | ((host_int & uint64_t{0xFF00000000000000}) >> 56));

  39. #endif

  40.     }

  41. 

  42.     inline uint32_t gbswap_32(uint32_t host_int)

  43.     {

  44. #if ABSL_HAVE_BUILTIN(__builtin_bswap32) || defined(__GNUC__)

  45.         return __builtin_bswap32(host_int);

  46. #elif defined(_MSC_VER)

  47.         return _byteswap_ulong(host_int);

  48. #else

  49.         return (((host_int & uint32_t{0xFF}) << 24) | ((host_int & uint32_t{0xFF00}) << 8) | ((host_int & uint32_t{0xFF0000}) >> 8) | ((host_int & uint32_t{0xFF000000}) >> 24));

  50. #endif

  51.     }

  52. 

  53.     inline uint16_t gbswap_16(uint16_t host_int)

  54.     {

  55. #if ABSL_HAVE_BUILTIN(__builtin_bswap16) || defined(__GNUC__)

  56.         return __builtin_bswap16(host_int);

  57. #elif defined(_MSC_VER)

  58.         return _byteswap_ushort(host_int);

  59. #else

  60.         return (((host_int & uint16_t{0xFF}) << 8) | ((host_int & uint16_t{0xFF00}) >> 8));

  61. #endif

  62.     }

  63. 

  64. #ifdef ABSL_IS_LITTLE_ENDIAN

  65. 

  66.     // Portable definitions for htonl (host-to-network) and friends on little-endian

  67.     // architectures.

  68.     inline uint16_t ghtons(uint16_t x)

  69.     {

  70.         return gbswap_16(x);

  71.     }

  72.     inline uint32_t ghtonl(uint32_t x)

  73.     {

  74.         return gbswap_32(x);

  75.     }

  76.     inline uint64_t ghtonll(uint64_t x)

  77.     {

  78.         return gbswap_64(x);

  79.     }

  80. 

  81. #elif defined ABSL_IS_BIG_ENDIAN

  82. 

  83.     // Portable definitions for htonl (host-to-network) etc on big-endian

  84.     // architectures. These definitions are simpler since the host byte order is the

  85.     // same as network byte order.

  86.     inline uint16_t ghtons(uint16_t x)

  87.     {

  88.         return x;

  89.     }

  90.     inline uint32_t ghtonl(uint32_t x)

  91.     {

  92.         return x;

  93.     }

  94.     inline uint64_t ghtonll(uint64_t x)

  95.     {

  96.         return x;

  97.     }

  98. 

  99. #else

  100. #error \

  101.     "Unsupported byte order: Either ABSL_IS_BIG_ENDIAN or " \

  102.        "ABSL_IS_LITTLE_ENDIAN must be defined"

  103. #endif  // byte order

  104. 

  105.     inline uint16_t gntohs(uint16_t x)

  106.     {

  107.         return ghtons(x);

  108.     }

  109.     inline uint32_t gntohl(uint32_t x)

  110.     {

  111.         return ghtonl(x);

  112.     }

  113.     inline uint64_t gntohll(uint64_t x)

  114.     {

  115.         return ghtonll(x);

  116.     }

  117. 

  118.     // Utilities to convert numbers between the current hosts's native byte

  119.     // order and little-endian byte order

  120.     //

  121.     // Load/Store methods are alignment safe

  122.     namespace little_endian

  123.     {

  124. // Conversion functions.

  125. #ifdef ABSL_IS_LITTLE_ENDIAN

  126. 

  127.         inline uint16_t FromHost16(uint16_t x)

  128.         {

  129.             return x;

  130.         }

  131.         inline uint16_t ToHost16(uint16_t x)

  132.         {

  133.             return x;

  134.         }

  135. 

  136.         inline uint32_t FromHost32(uint32_t x)

  137.         {

  138.             return x;

  139.         }

  140.         inline uint32_t ToHost32(uint32_t x)

  141.         {

  142.             return x;

  143.         }

  144. 

  145.         inline uint64_t FromHost64(uint64_t x)

  146.         {

  147.             return x;

  148.         }

  149.         inline uint64_t ToHost64(uint64_t x)

  150.         {

  151.             return x;

  152.         }

  153. 

  154.         inline constexpr bool IsLittleEndian()

  155.         {

  156.             return true;

  157.         }

  158. 

  159. #elif defined ABSL_IS_BIG_ENDIAN

  160. 

  161.         inline uint16_t FromHost16(uint16_t x)

  162.         {

  163.             return gbswap_16(x);

  164.         }

  165.         inline uint16_t ToHost16(uint16_t x)

  166.         {

  167.             return gbswap_16(x);

  168.         }

  169. 

  170.         inline uint32_t FromHost32(uint32_t x)

  171.         {

  172.             return gbswap_32(x);

  173.         }

  174.         inline uint32_t ToHost32(uint32_t x)

  175.         {

  176.             return gbswap_32(x);

  177.         }

  178. 

  179.         inline uint64_t FromHost64(uint64_t x)

  180.         {

  181.             return gbswap_64(x);

  182.         }

  183.         inline uint64_t ToHost64(uint64_t x)

  184.         {

  185.             return gbswap_64(x);

  186.         }

  187. 

  188.         inline constexpr bool IsLittleEndian()

  189.         {

  190.             return false;

  191.         }

  192. 

  193. #endif /* ENDIAN */

  194. 

  195.         inline uint8_t FromHost(uint8_t x)

  196.         {

  197.             return x;

  198.         }

  199.         inline uint16_t FromHost(uint16_t x)

  200.         {

  201.             return FromHost16(x);

  202.         }

  203.         inline uint32_t FromHost(uint32_t x)

  204.         {

  205.             return FromHost32(x);

  206.         }

  207.         inline uint64_t FromHost(uint64_t x)

  208.         {

  209.             return FromHost64(x);

  210.         }

  211.         inline uint8_t ToHost(uint8_t x)

  212.         {

  213.             return x;

  214.         }

  215.         inline uint16_t ToHost(uint16_t x)

  216.         {

  217.             return ToHost16(x);

  218.         }

  219.         inline uint32_t ToHost(uint32_t x)

  220.         {

  221.             return ToHost32(x);

  222.         }

  223.         inline uint64_t ToHost(uint64_t x)

  224.         {

  225.             return ToHost64(x);

  226.         }

  227. 

  228.         inline int8_t FromHost(int8_t x)

  229.         {

  230.             return x;

  231.         }

  232.         inline int16_t FromHost(int16_t x)

  233.         {

  234.             return bit_cast<int16_t>(FromHost16(bit_cast<uint16_t>(x)));

  235.         }

  236.         inline int32_t FromHost(int32_t x)

  237.         {

  238.             return bit_cast<int32_t>(FromHost32(bit_cast<uint32_t>(x)));

  239.         }

  240.         inline int64_t FromHost(int64_t x)

  241.         {

  242.             return bit_cast<int64_t>(FromHost64(bit_cast<uint64_t>(x)));

  243.         }

  244.         inline int8_t ToHost(int8_t x)

  245.         {

  246.             return x;

  247.         }

  248.         inline int16_t ToHost(int16_t x)

  249.         {

  250.             return bit_cast<int16_t>(ToHost16(bit_cast<uint16_t>(x)));

  251.         }

  252.         inline int32_t ToHost(int32_t x)

  253.         {

  254.             return bit_cast<int32_t>(ToHost32(bit_cast<uint32_t>(x)));

  255.         }

  256.         inline int64_t ToHost(int64_t x)

  257.         {

  258.             return bit_cast<int64_t>(ToHost64(bit_cast<uint64_t>(x)));

  259.         }

  260. 

  261.         // Functions to do unaligned loads and stores in little-endian order.

  262.         inline uint16_t Load16(const void* p)

  263.         {

  264.             return ToHost16(ABSL_INTERNAL_UNALIGNED_LOAD16(p));

  265.         }

  266. 

  267.         inline void Store16(void* p, uint16_t v)

  268.         {

  269.             ABSL_INTERNAL_UNALIGNED_STORE16(p, FromHost16(v));

  270.         }

  271. 

  272.         inline uint32_t Load32(const void* p)

  273.         {

  274.             return ToHost32(ABSL_INTERNAL_UNALIGNED_LOAD32(p));

  275.         }

  276. 

  277.         inline void Store32(void* p, uint32_t v)

  278.         {

  279.             ABSL_INTERNAL_UNALIGNED_STORE32(p, FromHost32(v));

  280.         }

  281. 

  282.         inline uint64_t Load64(const void* p)

  283.         {

  284.             return ToHost64(ABSL_INTERNAL_UNALIGNED_LOAD64(p));

  285.         }

  286. 

  287.         inline void Store64(void* p, uint64_t v)

  288.         {

  289.             ABSL_INTERNAL_UNALIGNED_STORE64(p, FromHost64(v));

  290.         }

  291. 

  292.     }  // namespace little_endian

  293. 

  294.     // Utilities to convert numbers between the current hosts's native byte

  295.     // order and big-endian byte order (same as network byte order)

  296.     //

  297.     // Load/Store methods are alignment safe

  298.     namespace big_endian

  299.     {

  300. #ifdef ABSL_IS_LITTLE_ENDIAN

  301. 

  302.         inline uint16_t FromHost16(uint16_t x)

  303.         {

  304.             return gbswap_16(x);

  305.         }

  306.         inline uint16_t ToHost16(uint16_t x)

  307.         {

  308.             return gbswap_16(x);

  309.         }

  310. 

  311.         inline uint32_t FromHost32(uint32_t x)

  312.         {

  313.             return gbswap_32(x);

  314.         }

  315.         inline uint32_t ToHost32(uint32_t x)

  316.         {

  317.             return gbswap_32(x);

  318.         }

  319. 

  320.         inline uint64_t FromHost64(uint64_t x)

  321.         {

  322.             return gbswap_64(x);

  323.         }

  324.         inline uint64_t ToHost64(uint64_t x)

  325.         {

  326.             return gbswap_64(x);

  327.         }

  328. 

  329.         inline constexpr bool IsLittleEndian()

  330.         {

  331.             return true;

  332.         }

  333. 

  334. #elif defined ABSL_IS_BIG_ENDIAN

  335. 

  336.         inline uint16_t FromHost16(uint16_t x)

  337.         {

  338.             return x;

  339.         }

  340.         inline uint16_t ToHost16(uint16_t x)

  341.         {

  342.             return x;

  343.         }

  344. 

  345.         inline uint32_t FromHost32(uint32_t x)

  346.         {

  347.             return x;

  348.         }

  349.         inline uint32_t ToHost32(uint32_t x)

  350.         {

  351.             return x;

  352.         }

  353. 

  354.         inline uint64_t FromHost64(uint64_t x)

  355.         {

  356.             return x;

  357.         }

  358.         inline uint64_t ToHost64(uint64_t x)

  359.         {

  360.             return x;

  361.         }

  362. 

  363.         inline constexpr bool IsLittleEndian()

  364.         {

  365.             return false;

  366.         }

  367. 

  368. #endif /* ENDIAN */

  369. 

  370.         inline uint8_t FromHost(uint8_t x)

  371.         {

  372.             return x;

  373.         }

  374.         inline uint16_t FromHost(uint16_t x)

  375.         {

  376.             return FromHost16(x);

  377.         }

  378.         inline uint32_t FromHost(uint32_t x)

  379.         {

  380.             return FromHost32(x);

  381.         }

  382.         inline uint64_t FromHost(uint64_t x)

  383.         {

  384.             return FromHost64(x);

  385.         }

  386.         inline uint8_t ToHost(uint8_t x)

  387.         {

  388.             return x;

  389.         }

  390.         inline uint16_t ToHost(uint16_t x)

  391.         {

  392.             return ToHost16(x);

  393.         }

  394.         inline uint32_t ToHost(uint32_t x)

  395.         {

  396.             return ToHost32(x);

  397.         }

  398.         inline uint64_t ToHost(uint64_t x)

  399.         {

  400.             return ToHost64(x);

  401.         }

  402. 

  403.         inline int8_t FromHost(int8_t x)

  404.         {

  405.             return x;

  406.         }

  407.         inline int16_t FromHost(int16_t x)

  408.         {

  409.             return bit_cast<int16_t>(FromHost16(bit_cast<uint16_t>(x)));

  410.         }

  411.         inline int32_t FromHost(int32_t x)

  412.         {

  413.             return bit_cast<int32_t>(FromHost32(bit_cast<uint32_t>(x)));

  414.         }

  415.         inline int64_t FromHost(int64_t x)

  416.         {

  417.             return bit_cast<int64_t>(FromHost64(bit_cast<uint64_t>(x)));

  418.         }

  419.         inline int8_t ToHost(int8_t x)

  420.         {

  421.             return x;

  422.         }

  423.         inline int16_t ToHost(int16_t x)

  424.         {

  425.             return bit_cast<int16_t>(ToHost16(bit_cast<uint16_t>(x)));

  426.         }

  427.         inline int32_t ToHost(int32_t x)

  428.         {

  429.             return bit_cast<int32_t>(ToHost32(bit_cast<uint32_t>(x)));

  430.         }

  431.         inline int64_t ToHost(int64_t x)

  432.         {

  433.             return bit_cast<int64_t>(ToHost64(bit_cast<uint64_t>(x)));

  434.         }

  435. 

  436.         // Functions to do unaligned loads and stores in big-endian order.

  437.         inline uint16_t Load16(const void* p)

  438.         {

  439.             return ToHost16(ABSL_INTERNAL_UNALIGNED_LOAD16(p));

  440.         }

  441. 

  442.         inline void Store16(void* p, uint16_t v)

  443.         {

  444.             ABSL_INTERNAL_UNALIGNED_STORE16(p, FromHost16(v));

  445.         }

  446. 

  447.         inline uint32_t Load32(const void* p)

  448.         {

  449.             return ToHost32(ABSL_INTERNAL_UNALIGNED_LOAD32(p));

  450.         }

  451. 

  452.         inline void Store32(void* p, uint32_t v)

  453.         {

  454.             ABSL_INTERNAL_UNALIGNED_STORE32(p, FromHost32(v));

  455.         }

  456. 

  457.         inline uint64_t Load64(const void* p)

  458.         {

  459.             return ToHost64(ABSL_INTERNAL_UNALIGNED_LOAD64(p));

  460.         }

  461. 

  462.         inline void Store64(void* p, uint64_t v)

  463.         {

  464.             ABSL_INTERNAL_UNALIGNED_STORE64(p, FromHost64(v));

  465.         }

  466. 

  467.     }  // namespace big_endian

  468. 

  469.     ABSL_NAMESPACE_END

  470. }  // namespace absl

  471. 

  472. #endif  // ABSL_BASE_INTERNAL_ENDIAN_H_