ra8_c6link_arena.c

Go to the documentation of this file.

 
#include <stddef.h>
#include <stdint.h>
 
#include "ra8_attributes.h"
#include "ra8_c6link.h"
#include "ra8_c6link_internal.h"

typedef enum : uint32_t {
  k_ra8_c6link_arena_align = 8U,
  k_ra8_c6link_arena_mask = 7U,
} ra8_c6link_arena_t;
 
RA8_PRIV void* priv_c6link_arena_alloc(void* ctx, size_t size)
{
  ra8_c6link_t* link = (ra8_c6link_t*)ctx;
  if ((link == nullptr) || (link->arena == nullptr)) {
    return nullptr;
  }
 
  /* `arena_used` never exceeds `arena_bytes`, so this cannot underflow, and
     every later comparison stays inside the remaining space -- which is what
     lets the rounding below be checked without an overflow test that no
     reachable input could ever make true. */
  const uint32_t avail = link->arena_bytes - link->arena_used;
  if (size > (size_t)avail) {
    return nullptr;
  }
  const uint32_t want = (uint32_t)size;
  const uint32_t pad  = (uint32_t)((0U - want) & (uint32_t)k_ra8_c6link_arena_mask);
  if (pad > (avail - want)) {
    return nullptr;
  }
 
  const uint32_t at = link->arena_used;
  link->arena_used  = at + want + pad;
  link->arena_last  = at + 1U;
  return &link->arena[at];
}
 
RA8_PRIV void priv_c6link_arena_free(void* ctx, void* pointer)
{
  ra8_c6link_t* link = (ra8_c6link_t*)ctx;
  if ((link == nullptr) || (pointer == nullptr) || (link->arena_last == 0U)) {
    return;
  }
  const uint32_t at = link->arena_last - 1U;
  if (pointer == &link->arena[at]) {
    link->arena_used = at;
    link->arena_last = 0U;
  }
}
 
RA8_PRIV void priv_c6link_arena_reset(ra8_c6link_t* link)
{
  if (link == nullptr) {
    return;
  }
  link->arena_used = 0U;
  link->arena_last = 0U;
}
 
RA8_PRIV void priv_c6link_arena_bind(ProtobufCAllocator* out, ra8_c6link_t* link)
{
  if ((out == nullptr) || (link == nullptr)) {
    return;
  }
  out->alloc          = priv_c6link_arena_alloc;
  out->free           = priv_c6link_arena_free;
  out->allocator_data = link;
}