General

The code is nicely formatted, and the use of comments judicious. Thanks!

Tests?

There is a distinct lack of tests.

You do have a "brush" test, but it's quite insufficient in "depth". It doesn't test growth, doesn't test heterogeneous allocations (which may have caught the alignment issue), etc... I would advise writing a unit-test suite.

Documentation?

Documentation comments on the public API (header) would be more useful than comments on the function calls in main.

The fact that nullptr is returned on failure (instead of aborting) should be documented, even if it just follows malloc, for example.

Bug: realloc

(As also noted by @ComicSansMS)

The use of realloc is a terrible, terrible, mistake.

It means that if I have a pointer p allocated by arena_alloc and then at some point arena_alloc decides to call realloc (which I will never know) then using p afterwards will be Undefined Behavior.

You cannot use realloc. Instead you can:

• Never grow the arena.
• Keep a list of previous arena allocations, and add a new one as necessary.

I note that the typical approach is to never grow: the user can always create a new arena should they wish to, after all.

Bug: alignment

(As also noted by @Davislor)

The memory returned is not guaranteed to be aligned, leaving it to the user to do so.

You could simply align memory to alignof(max_align_t) as malloc does, it's as simple as just rounding up the allocation size to a multiple of it prior to bumping count.

Note, though, that with the rise of SIMD, many types are now more aligned than max_align_t (which cannot be changed for backward compatibility reason) and thus new C versions provide aligned_alloc instead.

I would advise following the new API. If anything, it means that you do get the benefit of packing memory more tightly, by not wasting up to alignof(max_align_t) - 1 bytes between allocations. For example when allocating two string buffers one after another. The added flexibility may add a slight cost to the call (a few instructions), though, so it's a trade-off.

Bug: overflow

Beware that the alloc_size argument passed to arena_alloc may be so large (consider SIZE_MAX) that arena->count + alloc_size may overflow, thereby wrapping around at 0 and returning a very small total, which may then compare less than arena->capacity.

Handling of overflow requires some care: using a > b - c rather than a + c > b is better, though that may require proving c <= b first.

API Improvements

There are two improvements which could be worthwhile:

1. Allow passing an initial size to the arena_new function, rather than picking an arbitrary one. The user is better placed to know how much they'll need.
2. Pass the alignment to arena_alloc, as discussed above.

Aside: good use of __attribute__((nonnull))!

API Additions

Some functions could be useful:

• Array allocation: where element size and number of elements are passed separately, so the multiplication can be checked not to overflow.
• Reallocation: by keeping track of the last size allocated, or by having the user supply the original size of the allocation to reallocate, you can detect whether it's the last, and if so extend in place instead of copying. Can be handy.
• Reset: rather than having the user destroy and re-create a fresh arena, a reset function (which just resets count) is more efficient.

Considerations

It may be worth annotating arena_alloc with __attribute__((malloc)), instructing GCC that the returned pointer cannot alias any other pointer.

While in theory the arena pointer does point to a memory block which aliases with the return value, in practice the "allocated" block is not accessed via arena for the lifetime of the pointer, so this should be sound.

Putting it altogether

Core of header:

/* Bump allocator arena. */
typedef struct arena Arena;

/* Returns a new arena with the specific `capacity`.

   On allocation failure, returns `nullptr`. */
Arena *arena_new(size_t capacity);

/* Destroys the arena, freeing its memory.

   Any pointer allocated by this arena is invalidated. */
void arena_destroy(Arena *arena);

/* Resets the arena, invalidating all existing allocations.

   While existing pointers allocated by this arena are this valid as far as the
   language is concerned, they should be considered invalid as using them may
   cause Undefined Behavior. */
void arena_reset(Arena *arena) ATTRIB_NONNULL;

/* Allocates a pointer from the arena.

   The allocated pointer is at least aligned to `alignment`, and is valid until
   the arena is reset or destroyed.

   `alignment` must be a power of 2.

   `size` must be a multiple of `alignment`. */
void *arena_alloc(Arena *arena, size_t alignment, size_t size) ATTRIB_NONNULL;

Core of source:

struct arena {
    size_t count;
    size_t capacity;
    uint8_t pool[];
};

Arena *arena_new(size_t capacity)
{
    Arena *a = calloc(1, sizeof *a + capacity);
    a->capacity = capacity;
    return a;
}

void arena_destroy(Arena *arena)
{
    free(arena);
}

void arena_reset(Arena *arena)
{
    arena->count = 0;
}

void *arena_alloc(Arena *arena, size_t alignment, size_t size)
{
    assert(alignment == 1 || !(alignment & (alignment - 1)));
    assert(size / alignment * alignment == size);

    char* p = arena->pool + arena->count;

    uintptr_t original = ((uintptr_t) p);

    if (original > UINTPTR_MAX - alignment) {
        return nullptr;
    }

    /*
       Rounds up the pointer value to the next multiple of alignment.
    
       - With alignment being a power of 2, alignment - 1 is of the form 
         0b001..1.
       - Thus "x & !(alignment - 1)" rounds x down to the previous multiple of
         alignment.
       - And "(x + alignment - 1) & !(alignment -1)" rounds up.
    */
    uintptr_t aligned = (original + alignment - 1) & !(alignment - 1);

    size_t offset = aligned - original;

    if (size > SIZE_MAX - offset) {
        return nullptr;
    }

    size += offset;

    if (size > arena->capacity - arena->count) {
        return nullptr;
    }

    arena->count += size;

    /* Equal to "aligned", but preserves provenance */
    return p + offset;
}
```