1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
|
// Copyright © Tavian Barnes <tavianator@tavianator.com>
// SPDX-License-Identifier: 0BSD
/**
* Memory allocation.
*/
#ifndef BFS_ALLOC_H
#define BFS_ALLOC_H
#include "config.h"
#include <stddef.h>
/** Round down to a multiple of an alignment. */
static inline size_t align_floor(size_t align, size_t size) {
return size & ~(align - 1);
}
/** Round up to a multiple of an alignment. */
static inline size_t align_ceil(size_t align, size_t size) {
return align_floor(align, size + align - 1);
}
/**
* Saturating array size.
*
* @param align
* Array element alignment.
* @param size
* Array element size.
* @param count
* Array element count.
* @return
* size * count, saturating to the maximum aligned value on overflow.
*/
static inline size_t array_size(size_t align, size_t size, size_t count) {
size_t ret = size * count;
return ret / size == count ? ret : ~(align - 1);
}
/** Saturating array sizeof. */
#define sizeof_array(type, count) \
array_size(alignof(type), sizeof(type), count)
/** Size of a struct/union field. */
#define sizeof_member(type, member) \
sizeof(((type *)NULL)->member)
/**
* Saturating flexible struct size.
*
* @param align
* Struct alignment.
* @param min
* Minimum struct size.
* @param offset
* Flexible array member offset.
* @param size
* Flexible array element size.
* @param count
* Flexible array element count.
* @return
* The size of the struct with count flexible array elements. Saturates
* to the maximum aligned value on overflow.
*/
static inline size_t flex_size(size_t align, size_t min, size_t offset, size_t size, size_t count) {
size_t ret = size * count;
size_t overflow = ret / size != count;
size_t extra = offset + align - 1;
ret += extra;
overflow |= ret < extra;
ret |= -overflow;
ret = align_floor(align, ret);
// Make sure flex_sizeof(type, member, 0) >= sizeof(type), even if the
// type has more padding than necessary for alignment
if (min > align_ceil(align, offset)) {
ret = ret < min ? min : ret;
}
return ret;
}
/**
* Computes the size of a flexible struct.
*
* @param type
* The type of the struct containing the flexible array.
* @param member
* The name of the flexible array member.
* @param count
* The length of the flexible array.
* @return
* The size of the struct with count flexible array elements. Saturates
* to the maximum aligned value on overflow.
*/
#define sizeof_flex(type, member, count) \
flex_size(alignof(type), sizeof(type), offsetof(type, member), sizeof_member(type, member[0]), count)
/**
* General memory allocator.
*
* @param align
* The required alignment.
* @param size
* The size of the allocation.
* @return
* The allocated memory, or NULL on failure.
*/
void *alloc(size_t align, size_t size);
/**
* Zero-initialized memory allocator.
*
* @param align
* The required alignment.
* @param size
* The size of the allocation.
* @return
* The allocated memory, or NULL on failure.
*/
void *zalloc(size_t align, size_t size);
/** Allocate memory for the given type. */
#define ALLOC(type) \
(type *)alloc(alignof(type), sizeof(type))
/** Allocate zeroed memory for the given type. */
#define ZALLOC(type) \
(type *)zalloc(alignof(type), sizeof(type))
/** Allocate memory for an array. */
#define ALLOC_ARRAY(type, count) \
(type *)alloc(alignof(type), sizeof_array(type, count));
/** Allocate zeroed memory for an array. */
#define ZALLOC_ARRAY(type, count) \
(type *)zalloc(alignof(type), sizeof_array(type, count));
/** Allocate memory for a flexible struct. */
#define ALLOC_FLEX(type, member, count) \
(type *)alloc(alignof(type), sizeof_flex(type, member, count))
/** Allocate zeroed memory for a flexible struct. */
#define ZALLOC_FLEX(type, member, count) \
(type *)zalloc(alignof(type), sizeof_flex(type, member, count))
#endif // BFS_ALLOC_H
|
