notaz.gp2x.de / pcsx_rearmed.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
git subrepo pull (merge) --force deps/libchdr
[pcsx_rearmed.git] / deps / libchdr / deps / zstd-1.5.5 / lib / common / mem.h
CommitLineData
648db22b 1/*
2 * Copyright (c) Meta Platforms, Inc. and affiliates.
3 * All rights reserved.
4 *
5 * This source code is licensed under both the BSD-style license (found in the
6 * LICENSE file in the root directory of this source tree) and the GPLv2 (found
7 * in the COPYING file in the root directory of this source tree).
8 * You may select, at your option, one of the above-listed licenses.
9 */
10
11#ifndef MEM_H_MODULE
12#define MEM_H_MODULE
13
14#if defined (__cplusplus)
15extern "C" {
16#endif
17
18/*-****************************************
19* Dependencies
20******************************************/
21#include <stddef.h> /* size_t, ptrdiff_t */
22#include "compiler.h" /* __has_builtin */
23#include "debug.h" /* DEBUG_STATIC_ASSERT */
24#include "zstd_deps.h" /* ZSTD_memcpy */
25
26
27/*-****************************************
28* Compiler specifics
29******************************************/
30#if defined(_MSC_VER) /* Visual Studio */
31# include <stdlib.h> /* _byteswap_ulong */
32# include <intrin.h> /* _byteswap_* */
33#endif
34#if defined(__GNUC__)
35# define MEM_STATIC static __inline __attribute__((unused))
36#elif defined (__cplusplus) || (defined (__STDC_VERSION__) && (__STDC_VERSION__ >= 199901L) /* C99 */)
37# define MEM_STATIC static inline
38#elif defined(_MSC_VER)
39# define MEM_STATIC static __inline
40#else
41# define MEM_STATIC static /* this version may generate warnings for unused static functions; disable the relevant warning */
42#endif
43
44/*-**************************************************************
45* Basic Types
46*****************************************************************/
47#if !defined (__VMS) && (defined (__cplusplus) || (defined (__STDC_VERSION__) && (__STDC_VERSION__ >= 199901L) /* C99 */) )
48# if defined(_AIX)
49# include <inttypes.h>
50# else
51# include <stdint.h> /* intptr_t */
52# endif
53 typedef uint8_t BYTE;
54 typedef uint8_t U8;
55 typedef int8_t S8;
56 typedef uint16_t U16;
57 typedef int16_t S16;
58 typedef uint32_t U32;
59 typedef int32_t S32;
60 typedef uint64_t U64;
61 typedef int64_t S64;
62#else
63# include <limits.h>
64#if CHAR_BIT != 8
65# error "this implementation requires char to be exactly 8-bit type"
66#endif
67 typedef unsigned char BYTE;
68 typedef unsigned char U8;
69 typedef signed char S8;
70#if USHRT_MAX != 65535
71# error "this implementation requires short to be exactly 16-bit type"
72#endif
73 typedef unsigned short U16;
74 typedef signed short S16;
75#if UINT_MAX != 4294967295
76# error "this implementation requires int to be exactly 32-bit type"
77#endif
78 typedef unsigned int U32;
79 typedef signed int S32;
80/* note : there are no limits defined for long long type in C90.
81 * limits exist in C99, however, in such case, <stdint.h> is preferred */
82 typedef unsigned long long U64;
83 typedef signed long long S64;
84#endif
85
86
87/*-**************************************************************
88* Memory I/O API
89*****************************************************************/
90/*=== Static platform detection ===*/
91MEM_STATIC unsigned MEM_32bits(void);
92MEM_STATIC unsigned MEM_64bits(void);
93MEM_STATIC unsigned MEM_isLittleEndian(void);
94
95/*=== Native unaligned read/write ===*/
96MEM_STATIC U16 MEM_read16(const void* memPtr);
97MEM_STATIC U32 MEM_read32(const void* memPtr);
98MEM_STATIC U64 MEM_read64(const void* memPtr);
99MEM_STATIC size_t MEM_readST(const void* memPtr);
100
101MEM_STATIC void MEM_write16(void* memPtr, U16 value);
102MEM_STATIC void MEM_write32(void* memPtr, U32 value);
103MEM_STATIC void MEM_write64(void* memPtr, U64 value);
104
105/*=== Little endian unaligned read/write ===*/
106MEM_STATIC U16 MEM_readLE16(const void* memPtr);
107MEM_STATIC U32 MEM_readLE24(const void* memPtr);
108MEM_STATIC U32 MEM_readLE32(const void* memPtr);
109MEM_STATIC U64 MEM_readLE64(const void* memPtr);
110MEM_STATIC size_t MEM_readLEST(const void* memPtr);
111
112MEM_STATIC void MEM_writeLE16(void* memPtr, U16 val);
113MEM_STATIC void MEM_writeLE24(void* memPtr, U32 val);
114MEM_STATIC void MEM_writeLE32(void* memPtr, U32 val32);
115MEM_STATIC void MEM_writeLE64(void* memPtr, U64 val64);
116MEM_STATIC void MEM_writeLEST(void* memPtr, size_t val);
117
118/*=== Big endian unaligned read/write ===*/
119MEM_STATIC U32 MEM_readBE32(const void* memPtr);
120MEM_STATIC U64 MEM_readBE64(const void* memPtr);
121MEM_STATIC size_t MEM_readBEST(const void* memPtr);
122
123MEM_STATIC void MEM_writeBE32(void* memPtr, U32 val32);
124MEM_STATIC void MEM_writeBE64(void* memPtr, U64 val64);
125MEM_STATIC void MEM_writeBEST(void* memPtr, size_t val);
126
127/*=== Byteswap ===*/
128MEM_STATIC U32 MEM_swap32(U32 in);
129MEM_STATIC U64 MEM_swap64(U64 in);
130MEM_STATIC size_t MEM_swapST(size_t in);
131
132
133/*-**************************************************************
134* Memory I/O Implementation
135*****************************************************************/
136/* MEM_FORCE_MEMORY_ACCESS : For accessing unaligned memory:
137 * Method 0 : always use `memcpy()`. Safe and portable.
138 * Method 1 : Use compiler extension to set unaligned access.
139 * Method 2 : direct access. This method is portable but violate C standard.
140 * It can generate buggy code on targets depending on alignment.
141 * Default : method 1 if supported, else method 0
142 */
143#ifndef MEM_FORCE_MEMORY_ACCESS /* can be defined externally, on command line for example */
144# ifdef __GNUC__
145# define MEM_FORCE_MEMORY_ACCESS 1
146# endif
147#endif
148
149MEM_STATIC unsigned MEM_32bits(void) { return sizeof(size_t)==4; }
150MEM_STATIC unsigned MEM_64bits(void) { return sizeof(size_t)==8; }
151
152MEM_STATIC unsigned MEM_isLittleEndian(void)
153{
154#if defined(__BYTE_ORDER__) && defined(__ORDER_LITTLE_ENDIAN__) && (__BYTE_ORDER__ == __ORDER_LITTLE_ENDIAN__)
155 return 1;
156#elif defined(__BYTE_ORDER__) && defined(__ORDER_BIG_ENDIAN__) && (__BYTE_ORDER__ == __ORDER_BIG_ENDIAN__)
157 return 0;
158#elif defined(__clang__) && __LITTLE_ENDIAN__
159 return 1;
160#elif defined(__clang__) && __BIG_ENDIAN__
161 return 0;
162#elif defined(_MSC_VER) && (_M_AMD64 || _M_IX86)
163 return 1;
164#elif defined(__DMC__) && defined(_M_IX86)
165 return 1;
166#else
167 const union { U32 u; BYTE c[4]; } one = { 1 }; /* don't use static : performance detrimental */
168 return one.c[0];
169#endif
170}
171
172#if defined(MEM_FORCE_MEMORY_ACCESS) && (MEM_FORCE_MEMORY_ACCESS==2)
173
174/* violates C standard, by lying on structure alignment.
175Only use if no other choice to achieve best performance on target platform */
176MEM_STATIC U16 MEM_read16(const void* memPtr) { return *(const U16*) memPtr; }
177MEM_STATIC U32 MEM_read32(const void* memPtr) { return *(const U32*) memPtr; }
178MEM_STATIC U64 MEM_read64(const void* memPtr) { return *(const U64*) memPtr; }
179MEM_STATIC size_t MEM_readST(const void* memPtr) { return *(const size_t*) memPtr; }
180
181MEM_STATIC void MEM_write16(void* memPtr, U16 value) { *(U16*)memPtr = value; }
182MEM_STATIC void MEM_write32(void* memPtr, U32 value) { *(U32*)memPtr = value; }
183MEM_STATIC void MEM_write64(void* memPtr, U64 value) { *(U64*)memPtr = value; }
184
185#elif defined(MEM_FORCE_MEMORY_ACCESS) && (MEM_FORCE_MEMORY_ACCESS==1)
186
187typedef __attribute__((aligned(1))) U16 unalign16;
188typedef __attribute__((aligned(1))) U32 unalign32;
189typedef __attribute__((aligned(1))) U64 unalign64;
190typedef __attribute__((aligned(1))) size_t unalignArch;
191
192MEM_STATIC U16 MEM_read16(const void* ptr) { return *(const unalign16*)ptr; }
193MEM_STATIC U32 MEM_read32(const void* ptr) { return *(const unalign32*)ptr; }
194MEM_STATIC U64 MEM_read64(const void* ptr) { return *(const unalign64*)ptr; }
195MEM_STATIC size_t MEM_readST(const void* ptr) { return *(const unalignArch*)ptr; }
196
197MEM_STATIC void MEM_write16(void* memPtr, U16 value) { *(unalign16*)memPtr = value; }
198MEM_STATIC void MEM_write32(void* memPtr, U32 value) { *(unalign32*)memPtr = value; }
199MEM_STATIC void MEM_write64(void* memPtr, U64 value) { *(unalign64*)memPtr = value; }
200
201#else
202
203/* default method, safe and standard.
204 can sometimes prove slower */
205
206MEM_STATIC U16 MEM_read16(const void* memPtr)
207{
208 U16 val; ZSTD_memcpy(&val, memPtr, sizeof(val)); return val;
209}
210
211MEM_STATIC U32 MEM_read32(const void* memPtr)
212{
213 U32 val; ZSTD_memcpy(&val, memPtr, sizeof(val)); return val;
214}
215
216MEM_STATIC U64 MEM_read64(const void* memPtr)
217{
218 U64 val; ZSTD_memcpy(&val, memPtr, sizeof(val)); return val;
219}
220
221MEM_STATIC size_t MEM_readST(const void* memPtr)
222{
223 size_t val; ZSTD_memcpy(&val, memPtr, sizeof(val)); return val;
224}
225
226MEM_STATIC void MEM_write16(void* memPtr, U16 value)
227{
228 ZSTD_memcpy(memPtr, &value, sizeof(value));
229}
230
231MEM_STATIC void MEM_write32(void* memPtr, U32 value)
232{
233 ZSTD_memcpy(memPtr, &value, sizeof(value));
234}
235
236MEM_STATIC void MEM_write64(void* memPtr, U64 value)
237{
238 ZSTD_memcpy(memPtr, &value, sizeof(value));
239}
240
241#endif /* MEM_FORCE_MEMORY_ACCESS */
242
243MEM_STATIC U32 MEM_swap32_fallback(U32 in)
244{
245 return ((in << 24) & 0xff000000 ) |
246 ((in << 8) & 0x00ff0000 ) |
247 ((in >> 8) & 0x0000ff00 ) |
248 ((in >> 24) & 0x000000ff );
249}
250
251MEM_STATIC U32 MEM_swap32(U32 in)
252{
253#if defined(_MSC_VER) /* Visual Studio */
254 return _byteswap_ulong(in);
255#elif (defined (__GNUC__) && (__GNUC__ * 100 + __GNUC_MINOR__ >= 403)) \
256 || (defined(__clang__) && __has_builtin(__builtin_bswap32))
257 return __builtin_bswap32(in);
258#else
259 return MEM_swap32_fallback(in);
260#endif
261}
262
263MEM_STATIC U64 MEM_swap64_fallback(U64 in)
264{
265 return ((in << 56) & 0xff00000000000000ULL) |
266 ((in << 40) & 0x00ff000000000000ULL) |
267 ((in << 24) & 0x0000ff0000000000ULL) |
268 ((in << 8) & 0x000000ff00000000ULL) |
269 ((in >> 8) & 0x00000000ff000000ULL) |
270 ((in >> 24) & 0x0000000000ff0000ULL) |
271 ((in >> 40) & 0x000000000000ff00ULL) |
272 ((in >> 56) & 0x00000000000000ffULL);
273}
274
275MEM_STATIC U64 MEM_swap64(U64 in)
276{
277#if defined(_MSC_VER) /* Visual Studio */
278 return _byteswap_uint64(in);
279#elif (defined (__GNUC__) && (__GNUC__ * 100 + __GNUC_MINOR__ >= 403)) \
280 || (defined(__clang__) && __has_builtin(__builtin_bswap64))
281 return __builtin_bswap64(in);
282#else
283 return MEM_swap64_fallback(in);
284#endif
285}
286
287MEM_STATIC size_t MEM_swapST(size_t in)
288{
289 if (MEM_32bits())
290 return (size_t)MEM_swap32((U32)in);
291 else
292 return (size_t)MEM_swap64((U64)in);
293}
294
295/*=== Little endian r/w ===*/
296
297MEM_STATIC U16 MEM_readLE16(const void* memPtr)
298{
299 if (MEM_isLittleEndian())
300 return MEM_read16(memPtr);
301 else {
302 const BYTE* p = (const BYTE*)memPtr;
303 return (U16)(p[0] + (p[1]<<8));
304 }
305}
306
307MEM_STATIC void MEM_writeLE16(void* memPtr, U16 val)
308{
309 if (MEM_isLittleEndian()) {
310 MEM_write16(memPtr, val);
311 } else {
312 BYTE* p = (BYTE*)memPtr;
313 p[0] = (BYTE)val;
314 p[1] = (BYTE)(val>>8);
315 }
316}
317
318MEM_STATIC U32 MEM_readLE24(const void* memPtr)
319{
320 return (U32)MEM_readLE16(memPtr) + ((U32)(((const BYTE*)memPtr)[2]) << 16);
321}
322
323MEM_STATIC void MEM_writeLE24(void* memPtr, U32 val)
324{
325 MEM_writeLE16(memPtr, (U16)val);
326 ((BYTE*)memPtr)[2] = (BYTE)(val>>16);
327}
328
329MEM_STATIC U32 MEM_readLE32(const void* memPtr)
330{
331 if (MEM_isLittleEndian())
332 return MEM_read32(memPtr);
333 else
334 return MEM_swap32(MEM_read32(memPtr));
335}
336
337MEM_STATIC void MEM_writeLE32(void* memPtr, U32 val32)
338{
339 if (MEM_isLittleEndian())
340 MEM_write32(memPtr, val32);
341 else
342 MEM_write32(memPtr, MEM_swap32(val32));
343}
344
345MEM_STATIC U64 MEM_readLE64(const void* memPtr)
346{
347 if (MEM_isLittleEndian())
348 return MEM_read64(memPtr);
349 else
350 return MEM_swap64(MEM_read64(memPtr));
351}
352
353MEM_STATIC void MEM_writeLE64(void* memPtr, U64 val64)
354{
355 if (MEM_isLittleEndian())
356 MEM_write64(memPtr, val64);
357 else
358 MEM_write64(memPtr, MEM_swap64(val64));
359}
360
361MEM_STATIC size_t MEM_readLEST(const void* memPtr)
362{
363 if (MEM_32bits())
364 return (size_t)MEM_readLE32(memPtr);
365 else
366 return (size_t)MEM_readLE64(memPtr);
367}
368
369MEM_STATIC void MEM_writeLEST(void* memPtr, size_t val)
370{
371 if (MEM_32bits())
372 MEM_writeLE32(memPtr, (U32)val);
373 else
374 MEM_writeLE64(memPtr, (U64)val);
375}
376
377/*=== Big endian r/w ===*/
378
379MEM_STATIC U32 MEM_readBE32(const void* memPtr)
380{
381 if (MEM_isLittleEndian())
382 return MEM_swap32(MEM_read32(memPtr));
383 else
384 return MEM_read32(memPtr);
385}
386
387MEM_STATIC void MEM_writeBE32(void* memPtr, U32 val32)
388{
389 if (MEM_isLittleEndian())
390 MEM_write32(memPtr, MEM_swap32(val32));
391 else
392 MEM_write32(memPtr, val32);
393}
394
395MEM_STATIC U64 MEM_readBE64(const void* memPtr)
396{
397 if (MEM_isLittleEndian())
398 return MEM_swap64(MEM_read64(memPtr));
399 else
400 return MEM_read64(memPtr);
401}
402
403MEM_STATIC void MEM_writeBE64(void* memPtr, U64 val64)
404{
405 if (MEM_isLittleEndian())
406 MEM_write64(memPtr, MEM_swap64(val64));
407 else
408 MEM_write64(memPtr, val64);
409}
410
411MEM_STATIC size_t MEM_readBEST(const void* memPtr)
412{
413 if (MEM_32bits())
414 return (size_t)MEM_readBE32(memPtr);
415 else
416 return (size_t)MEM_readBE64(memPtr);
417}
418
419MEM_STATIC void MEM_writeBEST(void* memPtr, size_t val)
420{
421 if (MEM_32bits())
422 MEM_writeBE32(memPtr, (U32)val);
423 else
424 MEM_writeBE64(memPtr, (U64)val);
425}
426
427/* code only tested on 32 and 64 bits systems */
428MEM_STATIC void MEM_check(void) { DEBUG_STATIC_ASSERT((sizeof(size_t)==4) || (sizeof(size_t)==8)); }
429
430
431#if defined (__cplusplus)
432}
433#endif
434
435#endif /* MEM_H_MODULE */
ARM optimized PCSX fork