| 2307 | } |
| 2308 | |
| 2309 | static void *realloc_impl(struct malloc_pool_s *pool, void *ptr, size_t size, |
| 2310 | bool lock) |
| 2311 | { |
| 2312 | if (ptr == NULL || ptr == MA_ZERO) |
| 2313 | return malloc_impl(pool, size, lock); |
| 2314 | |
| 2315 | pool = pool_init(pool); |
| 2316 | if ((uint8_t *)ptr < pool->base || |
| 2317 | (uint8_t *)ptr >= pool->base + MA_UNIT * (size_t)pool->end) |
| 2318 | panic("bad realloc() detected"); |
| 2319 | if ((uintptr_t)ptr % MA_UNIT != 0) |
| 2320 | panic("bad realloc() detected"); |
| 2321 | if (size == 0) |
| 2322 | { |
| 2323 | free_impl(pool, ptr, lock); |
| 2324 | return MA_ZERO; |
| 2325 | } |
| 2326 | off_t diff = (uint8_t *)ptr - pool->base - sizeof(struct malloc_node_s); |
| 2327 | uint32_t i = (uint32_t)(diff / MA_UNIT); |
| 2328 | |
| 2329 | size += sizeof(struct malloc_node_s); |
| 2330 | size_t size128 = size / MA_UNIT + (size % MA_UNIT? 1: 0); |
| 2331 | if (size128 > UINT32_MAX) |
| 2332 | { |
| 2333 | errno = ENOMEM; |
| 2334 | return NULL; |
| 2335 | } |
| 2336 | |
| 2337 | if (lock && mutex_lock(&pool->mutex) < 0) |
| 2338 | return NULL; |
| 2339 | uint32_t n = pool->root, ub = UINT32_MAX; |
| 2340 | bool left = false; |
| 2341 | while (true) |
| 2342 | { |
| 2343 | if (n == MA_NIL) |
| 2344 | panic("bad realloc() detected"); |
| 2345 | if (n == i) |
| 2346 | break; |
| 2347 | left = (i < n); |
| 2348 | if (left) |
| 2349 | ub = n; |
| 2350 | n = (left? MA_LEFT(pool, n): MA_RIGHT(pool, n)); |
| 2351 | } |
| 2352 | if (MA_MAGIC(pool, n) != MA_MAGIC_NUMBER) |
| 2353 | panic("bad realloc() detected"); |
| 2354 | uint32_t r = MA_RIGHT(pool, n); |
| 2355 | ub = (r != MA_NIL? MA_LB(pool, r): ub); |
| 2356 | |
| 2357 | if (n + size128 <= ub) |
| 2358 | { |
| 2359 | // In-place realloc: |
| 2360 | if (MA_SIZE(pool, n) == size128) |
| 2361 | { |
| 2362 | if (lock) mutex_unlock(&pool->mutex); |
| 2363 | return ptr; |
| 2364 | } |
| 2365 | if (!malloc_mem_realloc(pool, n, size128)) |
| 2366 | { |
no test coverage detected