THUAI6/CAPI/cpp/grpc/include/absl/base/internal/endian.h

// Copyright 2017 The Abseil Authors.
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
//      https://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
//

#ifndef ABSL_BASE_INTERNAL_ENDIAN_H_
#define ABSL_BASE_INTERNAL_ENDIAN_H_

#include <cstdint>
#include <cstdlib>

#include "absl/base/casts.h"
#include "absl/base/config.h"
#include "absl/base/internal/unaligned_access.h"
#include "absl/base/port.h"

namespace absl
{
    ABSL_NAMESPACE_BEGIN

    inline uint64_t gbswap_64(uint64_t host_int)
    {
#if ABSL_HAVE_BUILTIN(__builtin_bswap64) || defined(__GNUC__)
        return __builtin_bswap64(host_int);
#elif defined(_MSC_VER)
        return _byteswap_uint64(host_int);
#else
        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));
#endif
    }

    inline uint32_t gbswap_32(uint32_t host_int)
    {
#if ABSL_HAVE_BUILTIN(__builtin_bswap32) || defined(__GNUC__)
        return __builtin_bswap32(host_int);
#elif defined(_MSC_VER)
        return _byteswap_ulong(host_int);
#else
        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));
#endif
    }

    inline uint16_t gbswap_16(uint16_t host_int)
    {
#if ABSL_HAVE_BUILTIN(__builtin_bswap16) || defined(__GNUC__)
        return __builtin_bswap16(host_int);
#elif defined(_MSC_VER)
        return _byteswap_ushort(host_int);
#else
        return (((host_int & uint16_t{0xFF}) << 8) | ((host_int & uint16_t{0xFF00}) >> 8));
#endif
    }

#ifdef ABSL_IS_LITTLE_ENDIAN

    // Portable definitions for htonl (host-to-network) and friends on little-endian
    // architectures.
    inline uint16_t ghtons(uint16_t x)
    {
        return gbswap_16(x);
    }
    inline uint32_t ghtonl(uint32_t x)
    {
        return gbswap_32(x);
    }
    inline uint64_t ghtonll(uint64_t x)
    {
        return gbswap_64(x);
    }

#elif defined ABSL_IS_BIG_ENDIAN

    // Portable definitions for htonl (host-to-network) etc on big-endian
    // architectures. These definitions are simpler since the host byte order is the
    // same as network byte order.
    inline uint16_t ghtons(uint16_t x)
    {
        return x;
    }
    inline uint32_t ghtonl(uint32_t x)
    {
        return x;
    }
    inline uint64_t ghtonll(uint64_t x)
    {
        return x;
    }

#else
#error \
    "Unsupported byte order: Either ABSL_IS_BIG_ENDIAN or " \
       "ABSL_IS_LITTLE_ENDIAN must be defined"
#endif  // byte order

    inline uint16_t gntohs(uint16_t x)
    {
        return ghtons(x);
    }
    inline uint32_t gntohl(uint32_t x)
    {
        return ghtonl(x);
    }
    inline uint64_t gntohll(uint64_t x)
    {
        return ghtonll(x);
    }

    // Utilities to convert numbers between the current hosts's native byte
    // order and little-endian byte order
    //
    // Load/Store methods are alignment safe
    namespace little_endian
    {
// Conversion functions.
#ifdef ABSL_IS_LITTLE_ENDIAN

        inline uint16_t FromHost16(uint16_t x)
        {
            return x;
        }
        inline uint16_t ToHost16(uint16_t x)
        {
            return x;
        }

        inline uint32_t FromHost32(uint32_t x)
        {
            return x;
        }
        inline uint32_t ToHost32(uint32_t x)
        {
            return x;
        }

        inline uint64_t FromHost64(uint64_t x)
        {
            return x;
        }
        inline uint64_t ToHost64(uint64_t x)
        {
            return x;
        }

        inline constexpr bool IsLittleEndian()
        {
            return true;
        }

#elif defined ABSL_IS_BIG_ENDIAN

        inline uint16_t FromHost16(uint16_t x)
        {
            return gbswap_16(x);
        }
        inline uint16_t ToHost16(uint16_t x)
        {
            return gbswap_16(x);
        }

        inline uint32_t FromHost32(uint32_t x)
        {
            return gbswap_32(x);
        }
        inline uint32_t ToHost32(uint32_t x)
        {
            return gbswap_32(x);
        }

        inline uint64_t FromHost64(uint64_t x)
        {
            return gbswap_64(x);
        }
        inline uint64_t ToHost64(uint64_t x)
        {
            return gbswap_64(x);
        }

        inline constexpr bool IsLittleEndian()
        {
            return false;
        }

#endif /* ENDIAN */

        inline uint8_t FromHost(uint8_t x)
        {
            return x;
        }
        inline uint16_t FromHost(uint16_t x)
        {
            return FromHost16(x);
        }
        inline uint32_t FromHost(uint32_t x)
        {
            return FromHost32(x);
        }
        inline uint64_t FromHost(uint64_t x)
        {
            return FromHost64(x);
        }
        inline uint8_t ToHost(uint8_t x)
        {
            return x;
        }
        inline uint16_t ToHost(uint16_t x)
        {
            return ToHost16(x);
        }
        inline uint32_t ToHost(uint32_t x)
        {
            return ToHost32(x);
        }
        inline uint64_t ToHost(uint64_t x)
        {
            return ToHost64(x);
        }

        inline int8_t FromHost(int8_t x)
        {
            return x;
        }
        inline int16_t FromHost(int16_t x)
        {
            return bit_cast<int16_t>(FromHost16(bit_cast<uint16_t>(x)));
        }
        inline int32_t FromHost(int32_t x)
        {
            return bit_cast<int32_t>(FromHost32(bit_cast<uint32_t>(x)));
        }
        inline int64_t FromHost(int64_t x)
        {
            return bit_cast<int64_t>(FromHost64(bit_cast<uint64_t>(x)));
        }
        inline int8_t ToHost(int8_t x)
        {
            return x;
        }
        inline int16_t ToHost(int16_t x)
        {
            return bit_cast<int16_t>(ToHost16(bit_cast<uint16_t>(x)));
        }
        inline int32_t ToHost(int32_t x)
        {
            return bit_cast<int32_t>(ToHost32(bit_cast<uint32_t>(x)));
        }
        inline int64_t ToHost(int64_t x)
        {
            return bit_cast<int64_t>(ToHost64(bit_cast<uint64_t>(x)));
        }

        // Functions to do unaligned loads and stores in little-endian order.
        inline uint16_t Load16(const void* p)
        {
            return ToHost16(ABSL_INTERNAL_UNALIGNED_LOAD16(p));
        }

        inline void Store16(void* p, uint16_t v)
        {
            ABSL_INTERNAL_UNALIGNED_STORE16(p, FromHost16(v));
        }

        inline uint32_t Load32(const void* p)
        {
            return ToHost32(ABSL_INTERNAL_UNALIGNED_LOAD32(p));
        }

        inline void Store32(void* p, uint32_t v)
        {
            ABSL_INTERNAL_UNALIGNED_STORE32(p, FromHost32(v));
        }

        inline uint64_t Load64(const void* p)
        {
            return ToHost64(ABSL_INTERNAL_UNALIGNED_LOAD64(p));
        }

        inline void Store64(void* p, uint64_t v)
        {
            ABSL_INTERNAL_UNALIGNED_STORE64(p, FromHost64(v));
        }

    }  // namespace little_endian

    // Utilities to convert numbers between the current hosts's native byte
    // order and big-endian byte order (same as network byte order)
    //
    // Load/Store methods are alignment safe
    namespace big_endian
    {
#ifdef ABSL_IS_LITTLE_ENDIAN

        inline uint16_t FromHost16(uint16_t x)
        {
            return gbswap_16(x);
        }
        inline uint16_t ToHost16(uint16_t x)
        {
            return gbswap_16(x);
        }

        inline uint32_t FromHost32(uint32_t x)
        {
            return gbswap_32(x);
        }
        inline uint32_t ToHost32(uint32_t x)
        {
            return gbswap_32(x);
        }

        inline uint64_t FromHost64(uint64_t x)
        {
            return gbswap_64(x);
        }
        inline uint64_t ToHost64(uint64_t x)
        {
            return gbswap_64(x);
        }

        inline constexpr bool IsLittleEndian()
        {
            return true;
        }

#elif defined ABSL_IS_BIG_ENDIAN

        inline uint16_t FromHost16(uint16_t x)
        {
            return x;
        }
        inline uint16_t ToHost16(uint16_t x)
        {
            return x;
        }

        inline uint32_t FromHost32(uint32_t x)
        {
            return x;
        }
        inline uint32_t ToHost32(uint32_t x)
        {
            return x;
        }

        inline uint64_t FromHost64(uint64_t x)
        {
            return x;
        }
        inline uint64_t ToHost64(uint64_t x)
        {
            return x;
        }

        inline constexpr bool IsLittleEndian()
        {
            return false;
        }

#endif /* ENDIAN */

        inline uint8_t FromHost(uint8_t x)
        {
            return x;
        }
        inline uint16_t FromHost(uint16_t x)
        {
            return FromHost16(x);
        }
        inline uint32_t FromHost(uint32_t x)
        {
            return FromHost32(x);
        }
        inline uint64_t FromHost(uint64_t x)
        {
            return FromHost64(x);
        }
        inline uint8_t ToHost(uint8_t x)
        {
            return x;
        }
        inline uint16_t ToHost(uint16_t x)
        {
            return ToHost16(x);
        }
        inline uint32_t ToHost(uint32_t x)
        {
            return ToHost32(x);
        }
        inline uint64_t ToHost(uint64_t x)
        {
            return ToHost64(x);
        }

        inline int8_t FromHost(int8_t x)
        {
            return x;
        }
        inline int16_t FromHost(int16_t x)
        {
            return bit_cast<int16_t>(FromHost16(bit_cast<uint16_t>(x)));
        }
        inline int32_t FromHost(int32_t x)
        {
            return bit_cast<int32_t>(FromHost32(bit_cast<uint32_t>(x)));
        }
        inline int64_t FromHost(int64_t x)
        {
            return bit_cast<int64_t>(FromHost64(bit_cast<uint64_t>(x)));
        }
        inline int8_t ToHost(int8_t x)
        {
            return x;
        }
        inline int16_t ToHost(int16_t x)
        {
            return bit_cast<int16_t>(ToHost16(bit_cast<uint16_t>(x)));
        }
        inline int32_t ToHost(int32_t x)
        {
            return bit_cast<int32_t>(ToHost32(bit_cast<uint32_t>(x)));
        }
        inline int64_t ToHost(int64_t x)
        {
            return bit_cast<int64_t>(ToHost64(bit_cast<uint64_t>(x)));
        }

        // Functions to do unaligned loads and stores in big-endian order.
        inline uint16_t Load16(const void* p)
        {
            return ToHost16(ABSL_INTERNAL_UNALIGNED_LOAD16(p));
        }

        inline void Store16(void* p, uint16_t v)
        {
            ABSL_INTERNAL_UNALIGNED_STORE16(p, FromHost16(v));
        }

        inline uint32_t Load32(const void* p)
        {
            return ToHost32(ABSL_INTERNAL_UNALIGNED_LOAD32(p));
        }

        inline void Store32(void* p, uint32_t v)
        {
            ABSL_INTERNAL_UNALIGNED_STORE32(p, FromHost32(v));
        }

        inline uint64_t Load64(const void* p)
        {
            return ToHost64(ABSL_INTERNAL_UNALIGNED_LOAD64(p));
        }

        inline void Store64(void* p, uint64_t v)
        {
            ABSL_INTERNAL_UNALIGNED_STORE64(p, FromHost64(v));
        }

    }  // namespace big_endian

    ABSL_NAMESPACE_END
}  // namespace absl

#endif  // ABSL_BASE_INTERNAL_ENDIAN_H_