gallium/aux/util/u_transfer.c: Fix some -Wunused-param warnings.
[mesa.git] / src / compiler / blob.c
1 /*
2 * Copyright © 2014 Intel Corporation
3 *
4 * Permission is hereby granted, free of charge, to any person obtaining a
5 * copy of this software and associated documentation files (the "Software"),
6 * to deal in the Software without restriction, including without limitation
7 * the rights to use, copy, modify, merge, publish, distribute, sublicense,
8 * and/or sell copies of the Software, and to permit persons to whom the
9 * Software is furnished to do so, subject to the following conditions:
10 *
11 * The above copyright notice and this permission notice (including the next
12 * paragraph) shall be included in all copies or substantial portions of the
13 * Software.
14 *
15 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
16 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
17 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
18 * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
19 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
20 * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
21 * IN THE SOFTWARE.
22 */
23
24 #include <string.h>
25
26 #include "main/macros.h"
27 #include "blob.h"
28
29 #ifdef HAVE_VALGRIND
30 #include <valgrind.h>
31 #include <memcheck.h>
32 #define VG(x) x
33 #else
34 #define VG(x)
35 #endif
36
37 #define BLOB_INITIAL_SIZE 4096
38
39 /* Ensure that \blob will be able to fit an additional object of size
40 * \additional. The growing (if any) will occur by doubling the existing
41 * allocation.
42 */
43 static bool
44 grow_to_fit(struct blob *blob, size_t additional)
45 {
46 size_t to_allocate;
47 uint8_t *new_data;
48
49 if (blob->out_of_memory)
50 return false;
51
52 if (blob->size + additional <= blob->allocated)
53 return true;
54
55 if (blob->fixed_allocation) {
56 blob->out_of_memory = true;
57 return false;
58 }
59
60 if (blob->allocated == 0)
61 to_allocate = BLOB_INITIAL_SIZE;
62 else
63 to_allocate = blob->allocated * 2;
64
65 to_allocate = MAX2(to_allocate, blob->allocated + additional);
66
67 new_data = realloc(blob->data, to_allocate);
68 if (new_data == NULL) {
69 blob->out_of_memory = true;
70 return false;
71 }
72
73 blob->data = new_data;
74 blob->allocated = to_allocate;
75
76 return true;
77 }
78
79 /* Align the blob->size so that reading or writing a value at (blob->data +
80 * blob->size) will result in an access aligned to a granularity of \alignment
81 * bytes.
82 *
83 * \return True unless allocation fails
84 */
85 static bool
86 align_blob(struct blob *blob, size_t alignment)
87 {
88 const size_t new_size = ALIGN(blob->size, alignment);
89
90 if (blob->size < new_size) {
91 if (!grow_to_fit(blob, new_size - blob->size))
92 return false;
93
94 if (blob->data)
95 memset(blob->data + blob->size, 0, new_size - blob->size);
96 blob->size = new_size;
97 }
98
99 return true;
100 }
101
102 static void
103 align_blob_reader(struct blob_reader *blob, size_t alignment)
104 {
105 blob->current = blob->data + ALIGN(blob->current - blob->data, alignment);
106 }
107
108 void
109 blob_init(struct blob *blob)
110 {
111 blob->data = NULL;
112 blob->allocated = 0;
113 blob->size = 0;
114 blob->fixed_allocation = false;
115 blob->out_of_memory = false;
116 }
117
118 void
119 blob_init_fixed(struct blob *blob, void *data, size_t size)
120 {
121 blob->data = data;
122 blob->allocated = size;
123 blob->size = 0;
124 blob->fixed_allocation = true;
125 blob->out_of_memory = false;
126 }
127
128 bool
129 blob_overwrite_bytes(struct blob *blob,
130 size_t offset,
131 const void *bytes,
132 size_t to_write)
133 {
134 /* Detect an attempt to overwrite data out of bounds. */
135 if (offset + to_write < offset || blob->size < offset + to_write)
136 return false;
137
138 VG(VALGRIND_CHECK_MEM_IS_DEFINED(bytes, to_write));
139
140 if (blob->data)
141 memcpy(blob->data + offset, bytes, to_write);
142
143 return true;
144 }
145
146 bool
147 blob_write_bytes(struct blob *blob, const void *bytes, size_t to_write)
148 {
149 if (! grow_to_fit(blob, to_write))
150 return false;
151
152 VG(VALGRIND_CHECK_MEM_IS_DEFINED(bytes, to_write));
153
154 if (blob->data)
155 memcpy(blob->data + blob->size, bytes, to_write);
156 blob->size += to_write;
157
158 return true;
159 }
160
161 intptr_t
162 blob_reserve_bytes(struct blob *blob, size_t to_write)
163 {
164 intptr_t ret;
165
166 if (! grow_to_fit (blob, to_write))
167 return -1;
168
169 ret = blob->size;
170 blob->size += to_write;
171
172 return ret;
173 }
174
175 intptr_t
176 blob_reserve_uint32(struct blob *blob)
177 {
178 align_blob(blob, sizeof(uint32_t));
179 return blob_reserve_bytes(blob, sizeof(uint32_t));
180 }
181
182 intptr_t
183 blob_reserve_intptr(struct blob *blob)
184 {
185 align_blob(blob, sizeof(intptr_t));
186 return blob_reserve_bytes(blob, sizeof(intptr_t));
187 }
188
189 bool
190 blob_write_uint32(struct blob *blob, uint32_t value)
191 {
192 align_blob(blob, sizeof(value));
193
194 return blob_write_bytes(blob, &value, sizeof(value));
195 }
196
197 #define ASSERT_ALIGNED(_offset, _align) \
198 assert(ALIGN((_offset), (_align)) == (_offset))
199
200 bool
201 blob_overwrite_uint32 (struct blob *blob,
202 size_t offset,
203 uint32_t value)
204 {
205 ASSERT_ALIGNED(offset, sizeof(value));
206 return blob_overwrite_bytes(blob, offset, &value, sizeof(value));
207 }
208
209 bool
210 blob_write_uint64(struct blob *blob, uint64_t value)
211 {
212 align_blob(blob, sizeof(value));
213
214 return blob_write_bytes(blob, &value, sizeof(value));
215 }
216
217 bool
218 blob_write_intptr(struct blob *blob, intptr_t value)
219 {
220 align_blob(blob, sizeof(value));
221
222 return blob_write_bytes(blob, &value, sizeof(value));
223 }
224
225 bool
226 blob_overwrite_intptr (struct blob *blob,
227 size_t offset,
228 intptr_t value)
229 {
230 ASSERT_ALIGNED(offset, sizeof(value));
231 return blob_overwrite_bytes(blob, offset, &value, sizeof(value));
232 }
233
234 bool
235 blob_write_string(struct blob *blob, const char *str)
236 {
237 return blob_write_bytes(blob, str, strlen(str) + 1);
238 }
239
240 void
241 blob_reader_init(struct blob_reader *blob, const void *data, size_t size)
242 {
243 blob->data = data;
244 blob->end = blob->data + size;
245 blob->current = data;
246 blob->overrun = false;
247 }
248
249 /* Check that an object of size \size can be read from this blob.
250 *
251 * If not, set blob->overrun to indicate that we attempted to read too far.
252 */
253 static bool
254 ensure_can_read(struct blob_reader *blob, size_t size)
255 {
256 if (blob->overrun)
257 return false;
258
259 if (blob->current <= blob->end && blob->end - blob->current >= size)
260 return true;
261
262 blob->overrun = true;
263
264 return false;
265 }
266
267 const void *
268 blob_read_bytes(struct blob_reader *blob, size_t size)
269 {
270 const void *ret;
271
272 if (! ensure_can_read (blob, size))
273 return NULL;
274
275 ret = blob->current;
276
277 blob->current += size;
278
279 return ret;
280 }
281
282 void
283 blob_copy_bytes(struct blob_reader *blob, void *dest, size_t size)
284 {
285 const void *bytes;
286
287 bytes = blob_read_bytes(blob, size);
288 if (bytes == NULL)
289 return;
290
291 memcpy(dest, bytes, size);
292 }
293
294 /* These next three read functions have identical form. If we add any beyond
295 * these first three we should probably switch to generating these with a
296 * preprocessor macro.
297 */
298 uint32_t
299 blob_read_uint32(struct blob_reader *blob)
300 {
301 uint32_t ret;
302 int size = sizeof(ret);
303
304 align_blob_reader(blob, size);
305
306 if (! ensure_can_read(blob, size))
307 return 0;
308
309 ret = *((uint32_t*) blob->current);
310
311 blob->current += size;
312
313 return ret;
314 }
315
316 uint64_t
317 blob_read_uint64(struct blob_reader *blob)
318 {
319 uint64_t ret;
320 int size = sizeof(ret);
321
322 align_blob_reader(blob, size);
323
324 if (! ensure_can_read(blob, size))
325 return 0;
326
327 ret = *((uint64_t*) blob->current);
328
329 blob->current += size;
330
331 return ret;
332 }
333
334 intptr_t
335 blob_read_intptr(struct blob_reader *blob)
336 {
337 intptr_t ret;
338 int size = sizeof(ret);
339
340 align_blob_reader(blob, size);
341
342 if (! ensure_can_read(blob, size))
343 return 0;
344
345 ret = *((intptr_t *) blob->current);
346
347 blob->current += size;
348
349 return ret;
350 }
351
352 char *
353 blob_read_string(struct blob_reader *blob)
354 {
355 int size;
356 char *ret;
357 uint8_t *nul;
358
359 /* If we're already at the end, then this is an overrun. */
360 if (blob->current >= blob->end) {
361 blob->overrun = true;
362 return NULL;
363 }
364
365 /* Similarly, if there is no zero byte in the data remaining in this blob,
366 * we also consider that an overrun.
367 */
368 nul = memchr(blob->current, 0, blob->end - blob->current);
369
370 if (nul == NULL) {
371 blob->overrun = true;
372 return NULL;
373 }
374
375 size = nul - blob->current + 1;
376
377 assert(ensure_can_read(blob, size));
378
379 ret = (char *) blob->current;
380
381 blob->current += size;
382
383 return ret;
384 }