zstd/common/mem.h

0001 /* SPDX-License-Identifier: GPL-2.0+ OR BSD-3-Clause */
0002 /*
0003  * Copyright (c) Yann Collet, Facebook, Inc.
0004  * All rights reserved.
0005  *
0006  * This source code is licensed under both the BSD-style license (found in the
0007  * LICENSE file in the root directory of this source tree) and the GPLv2 (found
0008  * in the COPYING file in the root directory of this source tree).
0009  * You may select, at your option, one of the above-listed licenses.
0010  */
0011
0012 #ifndef MEM_H_MODULE
0013 #define MEM_H_MODULE
0014
0015 /*-****************************************
0016 *  Dependencies
0017 ******************************************/
0018 #include <asm/unaligned.h>  /* get_unaligned, put_unaligned* */
0019 #include <linux/compiler.h>  /* inline */
0020 #include <linux/swab.h>  /* swab32, swab64 */
0021 #include <linux/types.h>  /* size_t, ptrdiff_t */
0022 #include "debug.h"  /* DEBUG_STATIC_ASSERT */
0023
0024 /*-****************************************
0025 *  Compiler specifics
0026 ******************************************/
0027 #define MEM_STATIC static inline
0028
0029 /*-**************************************************************
0030 *  Basic Types
0031 *****************************************************************/
0032 typedef uint8_t  BYTE;
0033 typedef uint16_t U16;
0034 typedef int16_t  S16;
0035 typedef uint32_t U32;
0036 typedef int32_t  S32;
0037 typedef uint64_t U64;
0038 typedef int64_t  S64;
0039
0040 /*-**************************************************************
0041 *  Memory I/O API
0042 *****************************************************************/
0043 /*=== Static platform detection ===*/
0044 MEM_STATIC unsigned MEM_32bits(void);
0045 MEM_STATIC unsigned MEM_64bits(void);
0046 MEM_STATIC unsigned MEM_isLittleEndian(void);
0047
0048 /*=== Native unaligned read/write ===*/
0049 MEM_STATIC U16 MEM_read16(const void* memPtr);
0050 MEM_STATIC U32 MEM_read32(const void* memPtr);
0051 MEM_STATIC U64 MEM_read64(const void* memPtr);
0052 MEM_STATIC size_t MEM_readST(const void* memPtr);
0053
0054 MEM_STATIC void MEM_write16(void* memPtr, U16 value);
0055 MEM_STATIC void MEM_write32(void* memPtr, U32 value);
0056 MEM_STATIC void MEM_write64(void* memPtr, U64 value);
0057
0058 /*=== Little endian unaligned read/write ===*/
0059 MEM_STATIC U16 MEM_readLE16(const void* memPtr);
0060 MEM_STATIC U32 MEM_readLE24(const void* memPtr);
0061 MEM_STATIC U32 MEM_readLE32(const void* memPtr);
0062 MEM_STATIC U64 MEM_readLE64(const void* memPtr);
0063 MEM_STATIC size_t MEM_readLEST(const void* memPtr);
0064
0065 MEM_STATIC void MEM_writeLE16(void* memPtr, U16 val);
0066 MEM_STATIC void MEM_writeLE24(void* memPtr, U32 val);
0067 MEM_STATIC void MEM_writeLE32(void* memPtr, U32 val32);
0068 MEM_STATIC void MEM_writeLE64(void* memPtr, U64 val64);
0069 MEM_STATIC void MEM_writeLEST(void* memPtr, size_t val);
0070
0071 /*=== Big endian unaligned read/write ===*/
0072 MEM_STATIC U32 MEM_readBE32(const void* memPtr);
0073 MEM_STATIC U64 MEM_readBE64(const void* memPtr);
0074 MEM_STATIC size_t MEM_readBEST(const void* memPtr);
0075
0076 MEM_STATIC void MEM_writeBE32(void* memPtr, U32 val32);
0077 MEM_STATIC void MEM_writeBE64(void* memPtr, U64 val64);
0078 MEM_STATIC void MEM_writeBEST(void* memPtr, size_t val);
0079
0080 /*=== Byteswap ===*/
0081 MEM_STATIC U32 MEM_swap32(U32 in);
0082 MEM_STATIC U64 MEM_swap64(U64 in);
0083 MEM_STATIC size_t MEM_swapST(size_t in);
0084
0085 /*-**************************************************************
0086 *  Memory I/O Implementation
0087 *****************************************************************/
0088 MEM_STATIC unsigned MEM_32bits(void)
0089 {
0090     return sizeof(size_t) == 4;
0091 }
0092
0093 MEM_STATIC unsigned MEM_64bits(void)
0094 {
0095     return sizeof(size_t) == 8;
0096 }
0097
0098 #if defined(__LITTLE_ENDIAN)
0099 #define MEM_LITTLE_ENDIAN 1
0100 #else
0101 #define MEM_LITTLE_ENDIAN 0
0102 #endif
0103
0104 MEM_STATIC unsigned MEM_isLittleEndian(void)
0105 {
0106     return MEM_LITTLE_ENDIAN;
0107 }
0108
0109 MEM_STATIC U16 MEM_read16(const void *memPtr)
0110 {
0111     return get_unaligned((const U16 *)memPtr);
0112 }
0113
0114 MEM_STATIC U32 MEM_read32(const void *memPtr)
0115 {
0116     return get_unaligned((const U32 *)memPtr);
0117 }
0118
0119 MEM_STATIC U64 MEM_read64(const void *memPtr)
0120 {
0121     return get_unaligned((const U64 *)memPtr);
0122 }
0123
0124 MEM_STATIC size_t MEM_readST(const void *memPtr)
0125 {
0126     return get_unaligned((const size_t *)memPtr);
0127 }
0128
0129 MEM_STATIC void MEM_write16(void *memPtr, U16 value)
0130 {
0131     put_unaligned(value, (U16 *)memPtr);
0132 }
0133
0134 MEM_STATIC void MEM_write32(void *memPtr, U32 value)
0135 {
0136     put_unaligned(value, (U32 *)memPtr);
0137 }
0138
0139 MEM_STATIC void MEM_write64(void *memPtr, U64 value)
0140 {
0141     put_unaligned(value, (U64 *)memPtr);
0142 }
0143
0144 /*=== Little endian r/w ===*/
0145
0146 MEM_STATIC U16 MEM_readLE16(const void *memPtr)
0147 {
0148     return get_unaligned_le16(memPtr);
0149 }
0150
0151 MEM_STATIC void MEM_writeLE16(void *memPtr, U16 val)
0152 {
0153     put_unaligned_le16(val, memPtr);
0154 }
0155
0156 MEM_STATIC U32 MEM_readLE24(const void *memPtr)
0157 {
0158     return MEM_readLE16(memPtr) + (((const BYTE *)memPtr)[2] << 16);
0159 }
0160
0161 MEM_STATIC void MEM_writeLE24(void *memPtr, U32 val)
0162 {
0163     MEM_writeLE16(memPtr, (U16)val);
0164     ((BYTE *)memPtr)[2] = (BYTE)(val >> 16);
0165 }
0166
0167 MEM_STATIC U32 MEM_readLE32(const void *memPtr)
0168 {
0169     return get_unaligned_le32(memPtr);
0170 }
0171
0172 MEM_STATIC void MEM_writeLE32(void *memPtr, U32 val32)
0173 {
0174     put_unaligned_le32(val32, memPtr);
0175 }
0176
0177 MEM_STATIC U64 MEM_readLE64(const void *memPtr)
0178 {
0179     return get_unaligned_le64(memPtr);
0180 }
0181
0182 MEM_STATIC void MEM_writeLE64(void *memPtr, U64 val64)
0183 {
0184     put_unaligned_le64(val64, memPtr);
0185 }
0186
0187 MEM_STATIC size_t MEM_readLEST(const void *memPtr)
0188 {
0189     if (MEM_32bits())
0190         return (size_t)MEM_readLE32(memPtr);
0191     else
0192         return (size_t)MEM_readLE64(memPtr);
0193 }
0194
0195 MEM_STATIC void MEM_writeLEST(void *memPtr, size_t val)
0196 {
0197     if (MEM_32bits())
0198         MEM_writeLE32(memPtr, (U32)val);
0199     else
0200         MEM_writeLE64(memPtr, (U64)val);
0201 }
0202
0203 /*=== Big endian r/w ===*/
0204
0205 MEM_STATIC U32 MEM_readBE32(const void *memPtr)
0206 {
0207     return get_unaligned_be32(memPtr);
0208 }
0209
0210 MEM_STATIC void MEM_writeBE32(void *memPtr, U32 val32)
0211 {
0212     put_unaligned_be32(val32, memPtr);
0213 }
0214
0215 MEM_STATIC U64 MEM_readBE64(const void *memPtr)
0216 {
0217     return get_unaligned_be64(memPtr);
0218 }
0219
0220 MEM_STATIC void MEM_writeBE64(void *memPtr, U64 val64)
0221 {
0222     put_unaligned_be64(val64, memPtr);
0223 }
0224
0225 MEM_STATIC size_t MEM_readBEST(const void *memPtr)
0226 {
0227     if (MEM_32bits())
0228         return (size_t)MEM_readBE32(memPtr);
0229     else
0230         return (size_t)MEM_readBE64(memPtr);
0231 }
0232
0233 MEM_STATIC void MEM_writeBEST(void *memPtr, size_t val)
0234 {
0235     if (MEM_32bits())
0236         MEM_writeBE32(memPtr, (U32)val);
0237     else
0238         MEM_writeBE64(memPtr, (U64)val);
0239 }
0240
0241 MEM_STATIC U32 MEM_swap32(U32 in)
0242 {
0243     return swab32(in);
0244 }
0245
0246 MEM_STATIC U64 MEM_swap64(U64 in)
0247 {
0248     return swab64(in);
0249 }
0250
0251 MEM_STATIC size_t MEM_swapST(size_t in)
0252 {
0253     if (MEM_32bits())
0254         return (size_t)MEM_swap32((U32)in);
0255     else
0256         return (size_t)MEM_swap64((U64)in);
0257 }
0258
0259 #endif /* MEM_H_MODULE */