mem.h 4.2 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142
  1. /* SPDX-License-Identifier: (GPL-2.0 or BSD-3-Clause-Clear) */
  2. /**
  3. * Copyright (c) 2016-present, Yann Collet, Facebook, Inc.
  4. * All rights reserved.
  5. */
  6. #ifndef MEM_H_MODULE
  7. #define MEM_H_MODULE
  8. /*-****************************************
  9. * Dependencies
  10. ******************************************/
  11. #include <asm/unaligned.h>
  12. #include <compiler.h>
  13. #include <linux/string.h> /* memcpy */
  14. #include <linux/types.h> /* size_t, ptrdiff_t */
  15. /*-****************************************
  16. * Compiler specifics
  17. ******************************************/
  18. #define ZSTD_STATIC static __inline __attribute__((unused))
  19. /*-**************************************************************
  20. * Basic Types
  21. *****************************************************************/
  22. typedef uint8_t BYTE;
  23. typedef uint16_t U16;
  24. typedef int16_t S16;
  25. typedef uint32_t U32;
  26. typedef int32_t S32;
  27. typedef uint64_t U64;
  28. typedef int64_t S64;
  29. typedef ptrdiff_t iPtrDiff;
  30. typedef uintptr_t uPtrDiff;
  31. /*-**************************************************************
  32. * Memory I/O
  33. *****************************************************************/
  34. ZSTD_STATIC unsigned ZSTD_32bits(void) { return sizeof(size_t) == 4; }
  35. ZSTD_STATIC unsigned ZSTD_64bits(void) { return sizeof(size_t) == 8; }
  36. #if defined(__LITTLE_ENDIAN)
  37. #define ZSTD_LITTLE_ENDIAN 1
  38. #else
  39. #define ZSTD_LITTLE_ENDIAN 0
  40. #endif
  41. ZSTD_STATIC unsigned ZSTD_isLittleEndian(void) { return ZSTD_LITTLE_ENDIAN; }
  42. ZSTD_STATIC U16 ZSTD_read16(const void *memPtr) { return get_unaligned((const U16 *)memPtr); }
  43. ZSTD_STATIC U32 ZSTD_read32(const void *memPtr) { return get_unaligned((const U32 *)memPtr); }
  44. ZSTD_STATIC U64 ZSTD_read64(const void *memPtr) { return get_unaligned((const U64 *)memPtr); }
  45. ZSTD_STATIC size_t ZSTD_readST(const void *memPtr) { return get_unaligned((const size_t *)memPtr); }
  46. ZSTD_STATIC void ZSTD_write16(void *memPtr, U16 value) { put_unaligned(value, (U16 *)memPtr); }
  47. ZSTD_STATIC void ZSTD_write32(void *memPtr, U32 value) { put_unaligned(value, (U32 *)memPtr); }
  48. ZSTD_STATIC void ZSTD_write64(void *memPtr, U64 value) { put_unaligned(value, (U64 *)memPtr); }
  49. /*=== Little endian r/w ===*/
  50. ZSTD_STATIC U16 ZSTD_readLE16(const void *memPtr) { return get_unaligned_le16(memPtr); }
  51. ZSTD_STATIC void ZSTD_writeLE16(void *memPtr, U16 val) { put_unaligned_le16(val, memPtr); }
  52. ZSTD_STATIC U32 ZSTD_readLE24(const void *memPtr) { return ZSTD_readLE16(memPtr) + (((const BYTE *)memPtr)[2] << 16); }
  53. ZSTD_STATIC void ZSTD_writeLE24(void *memPtr, U32 val)
  54. {
  55. ZSTD_writeLE16(memPtr, (U16)val);
  56. ((BYTE *)memPtr)[2] = (BYTE)(val >> 16);
  57. }
  58. ZSTD_STATIC U32 ZSTD_readLE32(const void *memPtr) { return get_unaligned_le32(memPtr); }
  59. ZSTD_STATIC void ZSTD_writeLE32(void *memPtr, U32 val32) { put_unaligned_le32(val32, memPtr); }
  60. ZSTD_STATIC U64 ZSTD_readLE64(const void *memPtr) { return get_unaligned_le64(memPtr); }
  61. ZSTD_STATIC void ZSTD_writeLE64(void *memPtr, U64 val64) { put_unaligned_le64(val64, memPtr); }
  62. ZSTD_STATIC size_t ZSTD_readLEST(const void *memPtr)
  63. {
  64. if (ZSTD_32bits())
  65. return (size_t)ZSTD_readLE32(memPtr);
  66. else
  67. return (size_t)ZSTD_readLE64(memPtr);
  68. }
  69. ZSTD_STATIC void ZSTD_writeLEST(void *memPtr, size_t val)
  70. {
  71. if (ZSTD_32bits())
  72. ZSTD_writeLE32(memPtr, (U32)val);
  73. else
  74. ZSTD_writeLE64(memPtr, (U64)val);
  75. }
  76. /*=== Big endian r/w ===*/
  77. ZSTD_STATIC U32 ZSTD_readBE32(const void *memPtr) { return get_unaligned_be32(memPtr); }
  78. ZSTD_STATIC void ZSTD_writeBE32(void *memPtr, U32 val32) { put_unaligned_be32(val32, memPtr); }
  79. ZSTD_STATIC U64 ZSTD_readBE64(const void *memPtr) { return get_unaligned_be64(memPtr); }
  80. ZSTD_STATIC void ZSTD_writeBE64(void *memPtr, U64 val64) { put_unaligned_be64(val64, memPtr); }
  81. ZSTD_STATIC size_t ZSTD_readBEST(const void *memPtr)
  82. {
  83. if (ZSTD_32bits())
  84. return (size_t)ZSTD_readBE32(memPtr);
  85. else
  86. return (size_t)ZSTD_readBE64(memPtr);
  87. }
  88. ZSTD_STATIC void ZSTD_writeBEST(void *memPtr, size_t val)
  89. {
  90. if (ZSTD_32bits())
  91. ZSTD_writeBE32(memPtr, (U32)val);
  92. else
  93. ZSTD_writeBE64(memPtr, (U64)val);
  94. }
  95. /* function safe only for comparisons */
  96. ZSTD_STATIC U32 ZSTD_readMINMATCH(const void *memPtr, U32 length)
  97. {
  98. switch (length) {
  99. default:
  100. case 4: return ZSTD_read32(memPtr);
  101. case 3:
  102. if (ZSTD_isLittleEndian())
  103. return ZSTD_read32(memPtr) << 8;
  104. else
  105. return ZSTD_read32(memPtr) >> 8;
  106. }
  107. }
  108. #endif /* MEM_H_MODULE */