mem.h 4.7 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151
  1. /**
  2. * Copyright (c) 2016-present, Yann Collet, Facebook, Inc.
  3. * All rights reserved.
  4. *
  5. * This source code is licensed under the BSD-style license found in the
  6. * LICENSE file in the root directory of https://github.com/facebook/zstd.
  7. * An additional grant of patent rights can be found in the PATENTS file in the
  8. * same directory.
  9. *
  10. * This program is free software; you can redistribute it and/or modify it under
  11. * the terms of the GNU General Public License version 2 as published by the
  12. * Free Software Foundation. This program is dual-licensed; you may select
  13. * either version 2 of the GNU General Public License ("GPL") or BSD license
  14. * ("BSD").
  15. */
  16. #ifndef MEM_H_MODULE
  17. #define MEM_H_MODULE
  18. /*-****************************************
  19. * Dependencies
  20. ******************************************/
  21. #include <asm/unaligned.h>
  22. #include <linux/string.h> /* memcpy */
  23. #include <linux/types.h> /* size_t, ptrdiff_t */
  24. /*-****************************************
  25. * Compiler specifics
  26. ******************************************/
  27. #define ZSTD_STATIC static inline
  28. /*-**************************************************************
  29. * Basic Types
  30. *****************************************************************/
  31. typedef uint8_t BYTE;
  32. typedef uint16_t U16;
  33. typedef int16_t S16;
  34. typedef uint32_t U32;
  35. typedef int32_t S32;
  36. typedef uint64_t U64;
  37. typedef int64_t S64;
  38. typedef ptrdiff_t iPtrDiff;
  39. typedef uintptr_t uPtrDiff;
  40. /*-**************************************************************
  41. * Memory I/O
  42. *****************************************************************/
  43. ZSTD_STATIC unsigned ZSTD_32bits(void) { return sizeof(size_t) == 4; }
  44. ZSTD_STATIC unsigned ZSTD_64bits(void) { return sizeof(size_t) == 8; }
  45. #if defined(__LITTLE_ENDIAN)
  46. #define ZSTD_LITTLE_ENDIAN 1
  47. #else
  48. #define ZSTD_LITTLE_ENDIAN 0
  49. #endif
  50. ZSTD_STATIC unsigned ZSTD_isLittleEndian(void) { return ZSTD_LITTLE_ENDIAN; }
  51. ZSTD_STATIC U16 ZSTD_read16(const void *memPtr) { return get_unaligned((const U16 *)memPtr); }
  52. ZSTD_STATIC U32 ZSTD_read32(const void *memPtr) { return get_unaligned((const U32 *)memPtr); }
  53. ZSTD_STATIC U64 ZSTD_read64(const void *memPtr) { return get_unaligned((const U64 *)memPtr); }
  54. ZSTD_STATIC size_t ZSTD_readST(const void *memPtr) { return get_unaligned((const size_t *)memPtr); }
  55. ZSTD_STATIC void ZSTD_write16(void *memPtr, U16 value) { put_unaligned(value, (U16 *)memPtr); }
  56. ZSTD_STATIC void ZSTD_write32(void *memPtr, U32 value) { put_unaligned(value, (U32 *)memPtr); }
  57. ZSTD_STATIC void ZSTD_write64(void *memPtr, U64 value) { put_unaligned(value, (U64 *)memPtr); }
  58. /*=== Little endian r/w ===*/
  59. ZSTD_STATIC U16 ZSTD_readLE16(const void *memPtr) { return get_unaligned_le16(memPtr); }
  60. ZSTD_STATIC void ZSTD_writeLE16(void *memPtr, U16 val) { put_unaligned_le16(val, memPtr); }
  61. ZSTD_STATIC U32 ZSTD_readLE24(const void *memPtr) { return ZSTD_readLE16(memPtr) + (((const BYTE *)memPtr)[2] << 16); }
  62. ZSTD_STATIC void ZSTD_writeLE24(void *memPtr, U32 val)
  63. {
  64. ZSTD_writeLE16(memPtr, (U16)val);
  65. ((BYTE *)memPtr)[2] = (BYTE)(val >> 16);
  66. }
  67. ZSTD_STATIC U32 ZSTD_readLE32(const void *memPtr) { return get_unaligned_le32(memPtr); }
  68. ZSTD_STATIC void ZSTD_writeLE32(void *memPtr, U32 val32) { put_unaligned_le32(val32, memPtr); }
  69. ZSTD_STATIC U64 ZSTD_readLE64(const void *memPtr) { return get_unaligned_le64(memPtr); }
  70. ZSTD_STATIC void ZSTD_writeLE64(void *memPtr, U64 val64) { put_unaligned_le64(val64, memPtr); }
  71. ZSTD_STATIC size_t ZSTD_readLEST(const void *memPtr)
  72. {
  73. if (ZSTD_32bits())
  74. return (size_t)ZSTD_readLE32(memPtr);
  75. else
  76. return (size_t)ZSTD_readLE64(memPtr);
  77. }
  78. ZSTD_STATIC void ZSTD_writeLEST(void *memPtr, size_t val)
  79. {
  80. if (ZSTD_32bits())
  81. ZSTD_writeLE32(memPtr, (U32)val);
  82. else
  83. ZSTD_writeLE64(memPtr, (U64)val);
  84. }
  85. /*=== Big endian r/w ===*/
  86. ZSTD_STATIC U32 ZSTD_readBE32(const void *memPtr) { return get_unaligned_be32(memPtr); }
  87. ZSTD_STATIC void ZSTD_writeBE32(void *memPtr, U32 val32) { put_unaligned_be32(val32, memPtr); }
  88. ZSTD_STATIC U64 ZSTD_readBE64(const void *memPtr) { return get_unaligned_be64(memPtr); }
  89. ZSTD_STATIC void ZSTD_writeBE64(void *memPtr, U64 val64) { put_unaligned_be64(val64, memPtr); }
  90. ZSTD_STATIC size_t ZSTD_readBEST(const void *memPtr)
  91. {
  92. if (ZSTD_32bits())
  93. return (size_t)ZSTD_readBE32(memPtr);
  94. else
  95. return (size_t)ZSTD_readBE64(memPtr);
  96. }
  97. ZSTD_STATIC void ZSTD_writeBEST(void *memPtr, size_t val)
  98. {
  99. if (ZSTD_32bits())
  100. ZSTD_writeBE32(memPtr, (U32)val);
  101. else
  102. ZSTD_writeBE64(memPtr, (U64)val);
  103. }
  104. /* function safe only for comparisons */
  105. ZSTD_STATIC U32 ZSTD_readMINMATCH(const void *memPtr, U32 length)
  106. {
  107. switch (length) {
  108. default:
  109. case 4: return ZSTD_read32(memPtr);
  110. case 3:
  111. if (ZSTD_isLittleEndian())
  112. return ZSTD_read32(memPtr) << 8;
  113. else
  114. return ZSTD_read32(memPtr) >> 8;
  115. }
  116. }
  117. #endif /* MEM_H_MODULE */