동적 메모리: 어셈블리에서 힙 할당하기

The stack holds fixed, scope-bound data and is automatically reclaimed. The heap provides dynamic memory whose size and lifetime you control at run time.

Use heap memory when the size is unknown at assemble time or the data must outlive the procedure that created it, e.g. growing buffers and data structures.

The brk/sbrk syscall grows the programs data segment. It is low level and mostly superseded by mmap for general allocation.

mmap maps fresh anonymous pages and is the modern way to get large heap regions directly from the kernel.

Memory obtained from mmap is returned with munmap, telling the kernel those pages are free.

On Windows you call VirtualAlloc to reserve and commit pages, and VirtualFree to release them.

When linking with the C runtime, it is far simpler to call malloc and free, which manage a heap on top of the OS primitives.

Allocation can fail. malloc returns NULL and syscalls return a negative error code, so always test the result before using the pointer.

Every allocation needs a matching free. Forgetting to free leaks memory; freeing twice or using freed memory corrupts the heap.

Heap blocks are returned suitably aligned for any type. Manual allocators must respect alignment for SSE and atomic operations.

Heap bugs are subtle:

• Memory leaks from missing free
• Use-after-free
• Double free
• Buffer overruns past the allocation

Test your understanding of heap allocation.

You learned heap allocation:

• Stack is automatic; heap is run-time managed
• Linux: mmap/munmap or brk
• Windows: VirtualAlloc/VirtualFree
• With libc use malloc/free; always check for NULL and free once