Skip to main content

Heap Memory

The heap is used for dynamic memory allocation during runtime. Unlike the stack, which is managed automatically by the system in a last-in, first-out (LIFO) manner, the heap is managed by the application through library functions or system calls. Understanding the heap's behavior is essential for ARM64 application development and security analysis.

When an ARM64 application starts, the operating system sets aside a segment of memory for dynamic allocation, known as the heap. The initial size and boundaries of the heap segment are determined by the linker and the operating system but can be adjusted at runtime. The heap grows dynamically as the application requests more memory through allocation functions (malloc, calloc, realloc in C, for example) and shrinks when memory is freed (free in C).

The heap grows upwards towards higher memory addresses, which is opposite to the stack's growth direction. When an application requests a block of memory via an allocation function:

  1. Allocation Request: The request for memory allocation is handled by the memory management library, which communicates with the operating system's kernel to manage the heap.

  2. Memory Management: Depending on the size of the request and the current state of the heap, the memory management library decides whether to:

    • Allocate memory from the existing heap space.

    • Extend the heap by requesting more memory from the operating system.

  3. Heap Extension: If more space is needed, the library may use system calls like brk or mmap (on Unix-like systems) to extend the heap. The brk system call adjusts the end of the data segment to increase or decrease the heap size, while mmap maps files or devices into memory and can also be used to allocate large blocks of memory.

  4. Memory Allocation Algorithms: The library uses algorithms to manage heap memory efficiently, attempting to minimize fragmentation and maximize performance. Common algorithms include first-fit, best-fit, and buddy system, each with its trade-offs in terms of speed and memory utilization.

The heap is associated with the application's lifecycle and is managed explicitly by the application or implicitly by the garbage collector in managed languages (e.g., Objective-C, Java):

  1. Freeing Memory: It's the application's responsibility to free allocated memory when it is no longer needed. Failure to do so leads to memory leaks, where the application consumes more memory than necessary.
  2. Automatic Cleanup: Upon application termination, the operating system automatically reclaims all memory resources used by the application, including heap memory. This ensures that memory is not permanently lost due to leaks in applications.