Реализация malloc: проверка правильности выравнивания распределения

Как я уже упоминал в комментариях, ваш расчет выравнивания неверен. Представьте, что вам нужно выравнивание 4, а остаток по модулю равен 3. Вы не будете добавлять еще 3 — вы добавите 4 минус 3.

Вместо использования по модулю типичный способ выравнивания значения — добавить на единицу меньше, чем выравнивание (чтобы все, кроме нуля, гарантированно приводило к адресу на следующей границе выравнивания), а затем замаскировать все биты ниже, чем выравнивание:

pos = (pos + align - 1) & ~(align - 1);

Обратите внимание, что align должно быть беззнаковой степенью 2.

Поскольку здесь вы пытаетесь выровнять позицию в буфере, вы также должны быть осторожны, чтобы на самом деле это привело к такому же выравниванию в памяти.

По поводу автоматического выравнивания пользователь Эрик Постпишиль также прокомментировал:

Выравнивание объекта не превышает наибольшую степень двойки, делящую его размер. Например, если размер объекта составляет 12 байт, его требование к выравниванию составляет не более 4 байтов. Нет необходимости переходить к 16. Наибольшую степень двойки, которая делит size, можно рассчитать как size & -size.

Итак, сложив все это вместе, вот простой способ выравнивания по произвольному адресу:

#include <stddef.h>
#include <stdint.h>

size_t max_align(size_t size)
{
    size_t alignment = size & -size;
    return ((alignment - 1) & (sizeof(max_align_t) - 1)) + 1;
}

void* align(void* ptr, size_t alignment)
{
    return (void*)(((uintptr_t)ptr + alignment - 1) & ~(alignment - 1));
}

Обратите внимание на грязный трюк с обрезкой до sizeof(max_align_t). Это может быть или не быть лучше, чем простое введение ветки. Я не такой уж и грубый!

Посмотрите это в действии:

void test(char* buffer, size_t size)
{
    size_t alignment = max_align(size);
    char* aligned = align(buffer, alignment);
    size_t offset = aligned - buffer;
    printf("-align=%p size=%zu alignment=%zu offset=%zu\n",
        aligned, size, alignment, offset);
}

struct foo {
    int a;
    char b[2];
    int c;
    void* d;
};

struct __attribute((packed)) bar {
    int a;
    char b[2];
    int c;
    void* d;
};

int main(void)
{
    char buffer[256];
    for (size_t offset = 0; offset < 64; offset += 13) {
        char* base = buffer + offset;
        printf("\nbuffer=%p :\n", base);
        test(base, sizeof(struct foo));
        test(base, sizeof(struct bar));
    }
}

Пример вывода:

buffer=0x7ffc98db0770 :
-align=0x7ffc98db0770 size=24 alignment=8 offset=0
-align=0x7ffc98db0770 size=18 alignment=2 offset=0

buffer=0x7ffc98db077d :
-align=0x7ffc98db0780 size=24 alignment=8 offset=3
-align=0x7ffc98db077e size=18 alignment=2 offset=1

buffer=0x7ffc98db078a :
-align=0x7ffc98db0790 size=24 alignment=8 offset=6
-align=0x7ffc98db078a size=18 alignment=2 offset=0

buffer=0x7ffc98db0797 :
-align=0x7ffc98db0798 size=24 alignment=8 offset=1
-align=0x7ffc98db0798 size=18 alignment=2 offset=1

buffer=0x7ffc98db07a4 :
-align=0x7ffc98db07a8 size=24 alignment=8 offset=4
-align=0x7ffc98db07a4 size=18 alignment=2 offset=0