libunarchive/unxz/xz_config.h

/*
 * Private includes and definitions for userspace use of XZ Embedded
 *
 * Author: Lasse Collin <lasse.collin@tukaani.org>
 *
 * This file has been put into the public domain.
 * You can do whatever you want with this file.
 */

#ifndef XZ_CONFIG_H
#define XZ_CONFIG_H

/* Uncomment as needed to enable BCJ filter decoders. */
/* #define XZ_DEC_X86 */
/* #define XZ_DEC_POWERPC */
/* #define XZ_DEC_IA64 */
/* #define XZ_DEC_ARM */
/* #define XZ_DEC_ARMTHUMB */
/* #define XZ_DEC_SPARC */

#include <stdbool.h>
#include <stdlib.h>
#include <string.h>

#include "xz.h"

#define kmalloc(size, flags) malloc(size)
#define kfree(ptr) free(ptr)
#define vmalloc(size) malloc(size)
#define vfree(ptr) free(ptr)

#define memeq(a, b, size) (memcmp(a, b, size) == 0)
#define memzero(buf, size) memset(buf, 0, size)

#undef min
#undef min_t
#define min(x, y) ((x) < (y) ? (x) : (y))
#define min_t(type, x, y) min(x, y)

/*
 * Some functions have been marked with __always_inline to keep the
 * performance reasonable even when the compiler is optimizing for
 * small code size. You may be able to save a few bytes by #defining
 * __always_inline to plain inline, but don't complain if the code
 * becomes slow.
 *
 * NOTE: System headers on GNU/Linux may #define this macro already,
 * so if you want to change it, you need to #undef it first.
 */
#ifndef __always_inline
#	ifdef __GNUC__
#		define __always_inline \
			inline __attribute__((__always_inline__))
#	else
#		define __always_inline inline
#	endif
#endif

/*
 * Some functions are marked to never be inlined to reduce stack usage.
 * If you don't care about stack usage, you may want to modify this so
 * that noinline_for_stack is #defined to be empty even when using GCC.
 * Doing so may save a few bytes in binary size.
 */
#ifndef noinline_for_stack
#	ifdef __GNUC__
#		define noinline_for_stack __attribute__((__noinline__))
#	else
#		define noinline_for_stack
#	endif
#endif

/* Inline functions to access unaligned unsigned 32-bit integers */
#ifndef get_unaligned_le32
static inline uint32_t XZ_FUNC get_unaligned_le32(const uint8_t *buf)
{
	return (uint32_t)buf[0]
			| ((uint32_t)buf[1] << 8)
			| ((uint32_t)buf[2] << 16)
			| ((uint32_t)buf[3] << 24);
}
#endif

#ifndef get_unaligned_be32
static inline uint32_t XZ_FUNC get_unaligned_be32(const uint8_t *buf)
{
	return (uint32_t)(buf[0] << 24)
			| ((uint32_t)buf[1] << 16)
			| ((uint32_t)buf[2] << 8)
			| (uint32_t)buf[3];
}
#endif

#ifndef put_unaligned_le32
static inline void XZ_FUNC put_unaligned_le32(uint32_t val, uint8_t *buf)
{
	buf[0] = (uint8_t)val;
	buf[1] = (uint8_t)(val >> 8);
	buf[2] = (uint8_t)(val >> 16);
	buf[3] = (uint8_t)(val >> 24);
}
#endif

#ifndef put_unaligned_be32
static inline void XZ_FUNC put_unaligned_be32(uint32_t val, uint8_t *buf)
{
	buf[0] = (uint8_t)(val >> 24);
	buf[1] = (uint8_t)(val >> 16);
	buf[2] = (uint8_t)(val >> 8);
	buf[3] = (uint8_t)val;
}
#endif

/*
 * Use get_unaligned_le32() also for aligned access for simplicity. On
 * little endian systems, #define get_le32(ptr) (*(const uint32_t *)(ptr))
 * could save a few bytes in code size.
 */
#ifndef get_le32
#	define get_le32 get_unaligned_le32
#endif

#endif
1	/*
2	* Private includes and definitions for userspace use of XZ Embedded
3	*
4	* Author: Lasse Collin <lasse.collin@tukaani.org>
5	*
6	* This file has been put into the public domain.
7	* You can do whatever you want with this file.
8	*/
9
10	#ifndef XZ_CONFIG_H
11	#define XZ_CONFIG_H
12
13	/* Uncomment as needed to enable BCJ filter decoders. */
14	/* #define XZ_DEC_X86 */
15	/* #define XZ_DEC_POWERPC */
16	/* #define XZ_DEC_IA64 */
17	/* #define XZ_DEC_ARM */
18	/* #define XZ_DEC_ARMTHUMB */
19	/* #define XZ_DEC_SPARC */
20
21	#include <stdbool.h>
22	#include <stdlib.h>
23	#include <string.h>
24
25	#include "xz.h"
26
27	#define kmalloc(size, flags) malloc(size)
28	#define kfree(ptr) free(ptr)
29	#define vmalloc(size) malloc(size)
30	#define vfree(ptr) free(ptr)
31
32	#define memeq(a, b, size) (memcmp(a, b, size) == 0)
33	#define memzero(buf, size) memset(buf, 0, size)
34
35	#undef min
36	#undef min_t
37	#define min(x, y) ((x) < (y) ? (x) : (y))
38	#define min_t(type, x, y) min(x, y)
39
40	/*
41	* Some functions have been marked with __always_inline to keep the
42	* performance reasonable even when the compiler is optimizing for
43	* small code size. You may be able to save a few bytes by #defining
44	* __always_inline to plain inline, but don't complain if the code
45	* becomes slow.
46	*
47	* NOTE: System headers on GNU/Linux may #define this macro already,
48	* so if you want to change it, you need to #undef it first.
49	*/
50	#ifndef __always_inline
51	# ifdef __GNUC__
52	# define __always_inline \
53	inline __attribute__((__always_inline__))
54	# else
55	# define __always_inline inline
56	# endif
57	#endif
58
59	/*
60	* Some functions are marked to never be inlined to reduce stack usage.
61	* If you don't care about stack usage, you may want to modify this so
62	* that noinline_for_stack is #defined to be empty even when using GCC.
63	* Doing so may save a few bytes in binary size.
64	*/
65	#ifndef noinline_for_stack
66	# ifdef __GNUC__
67	# define noinline_for_stack __attribute__((__noinline__))
68	# else
69	# define noinline_for_stack
70	# endif
71	#endif
72
73	/* Inline functions to access unaligned unsigned 32-bit integers */
74	#ifndef get_unaligned_le32
75	static inline uint32_t XZ_FUNC get_unaligned_le32(const uint8_t *buf)
76	{
77	return (uint32_t)buf[0]
78	\| ((uint32_t)buf[1] << 8)
79	\| ((uint32_t)buf[2] << 16)
80	\| ((uint32_t)buf[3] << 24);
81	}
82	#endif
83
84	#ifndef get_unaligned_be32
85	static inline uint32_t XZ_FUNC get_unaligned_be32(const uint8_t *buf)
86	{
87	return (uint32_t)(buf[0] << 24)
88	\| ((uint32_t)buf[1] << 16)
89	\| ((uint32_t)buf[2] << 8)
90	\| (uint32_t)buf[3];
91	}
92	#endif
93
94	#ifndef put_unaligned_le32
95	static inline void XZ_FUNC put_unaligned_le32(uint32_t val, uint8_t *buf)
96	{
97	buf[0] = (uint8_t)val;
98	buf[1] = (uint8_t)(val >> 8);
99	buf[2] = (uint8_t)(val >> 16);
100	buf[3] = (uint8_t)(val >> 24);
101	}
102	#endif
103
104	#ifndef put_unaligned_be32
105	static inline void XZ_FUNC put_unaligned_be32(uint32_t val, uint8_t *buf)
106	{
107	buf[0] = (uint8_t)(val >> 24);
108	buf[1] = (uint8_t)(val >> 16);
109	buf[2] = (uint8_t)(val >> 8);
110	buf[3] = (uint8_t)val;
111	}
112	#endif
113
114	/*
115	* Use get_unaligned_le32() also for aligned access for simplicity. On
116	* little endian systems, #define get_le32(ptr) ((const uint32_t )(ptr))
117	* could save a few bytes in code size.
118	*/
119	#ifndef get_le32
120	# define get_le32 get_unaligned_le32
121	#endif
122
123	#endif