Stack and heap are not separate physical memory chips, and they are not CPU registers. They are conventional names for regions and allocation behavior inside a process’s virtual address space. Registers are a different thing entirely: the CPU’s working state while it executes code. Once you separate those layers, most of the confusion about where data “lives” goes away.
Where stack and heap actually live
A running program does not address physical RAM directly. It uses virtual addresses, and the hardware and operating system map those addresses to backing storage. The Linux mmap(2) manual page describes mmap() as creating a mapping in the calling process’s virtual address space. The top(1) manual describes virtual memory as an abstraction over physical addresses, one that helps keep each process’s address space isolated from the others.
As an Amazon Associate I earn from qualifying purchases.
That abstraction is why “stack is in RAM over here, heap is in RAM over there” is the wrong picture. Two things follow:
PC Slower Than It Used to Be?
A free scan shows the junk files, broken settings and background clutter dragging Windows down - then fixes them in one click.Free scan · Windows 10 & 11Crashes, No Sound, or Screen Glitches?
Random freezes, missing sound and display glitches usually trace back to one bad driver. Find and replace yours safely.Free scan · under a minute- A virtual region is not a dedicated physical block. The
top(1)manual lists several kinds of memory a process uses, including anonymous and file-backed forms, and names the stack,malloc/brkmemory, and explicit mappings among them. These are all ways of backing addresses in the process’s view. - Residency is not uniform. The sources do not establish a single universal policy for when a mapped page is actually resident in RAM. Do not assume that every byte a program allocates is immediately in physical memory.
The simplified layout model
Most diagrams of a process show a stack and a heap at opposite ends of the address space, with the stack growing downward and the heap growing upward. Michael Kerrisk’s Linux System Programming Essentials (2026) uses this kind of simplified Linux process layout to explain roles:
#1 Best Overall
- Stack: holds function-local variables and call-linkage information.
- Heap: holds dynamically allocated memory.
Treat that diagram as a teaching model. Growth direction is a convention of a particular implementation, not a law of computing. The Linux mmap(2) manual warns that the layout of mappings may change across Linux, C-library, and operating-system versions. Actual placement, and whether a given value exists in memory at all, can also change with the language, compiler optimization level, ABI, allocator, runtime, and operating system.
What happens in registers during a function call
Registers are small storage locations inside the CPU. They are not stack slots, and the stack is not a set of registers. The relationship is that registers hold addresses and state that the program uses to reach memory, including stack memory. The Kerrisk material identifies the saved stack-pointer and program-counter values as part of call-linkage information, which is the link between the two.
A call typically proceeds in the following stages. The exact details depend on the calling convention (ABI) and architecture, and the sources here do not establish one universal register convention.
Recommended Free Tools
- Arguments are prepared. The caller places argument values where the calling convention expects them, which may be registers, stack memory, or both.
- Control transfers to the callee. The program counter (instruction pointer) moves to the function’s first instruction. Saved state required to return is recorded. Whether the return address itself goes on the stack is architecture-dependent.
- The callee sets up its frame. The stack pointer is adjusted to reserve space for locals that need memory. Values that the compiler chooses to keep in registers may never occupy a stack slot.
- Locals are used. The compiler may keep a value in a register, spill it to the stack, eliminate it, or optimize away the source-level variable altogether. The source code does not tell you which of these happened.
- The function returns. The saved state is restored, the stack pointer is reset, and execution resumes in the caller.
The practical lesson is that “a local variable lives on the stack” is a useful first approximation, not a guarantee. Inspect the generated assembly, for example with your compiler’s output options, when you need to know what actually happened in a specific build.
Linux mechanics: brk, mmap, and allocators
On Linux, two interfaces explain much of how a process’s memory grows, but neither is the only mechanism in use.
brk() and sbrk()
brk() sets the program break, which the Linux brk(2) manual describes as the first location after the uninitialized data segment. Raising the break allocates memory for the process; lowering it deallocates memory. sbrk() changes the program’s data space by a given increment. Historically this is how a simple heap grew, but it should not be presented as the mechanism every allocator uses.
mmap()
mmap() establishes mappings in the process’s virtual address space. A mapping can be file-backed or anonymous, and private or shared. Large allocations and many allocator-managed regions are commonly created this way, so a process’s “heap” is not necessarily one contiguous block.
Allocators and arenas
A modern allocator chooses which mechanism to use and organizes its own arenas or chunks on top of them. This is why “one heap block” is an oversimplification. When you call malloc(), you are asking the allocator, which may satisfy the request from memory it already holds or request more from the operating system through one of the interfaces above.
MAP_STACK is a no-op on Linux
The Linux mmap(2) manual states that MAP_STACK is currently a no-op. Passing it does not give a mapping special stack placement on Linux, and code should not depend on it for that purpose.
Limits and failure modes
The address space is finite, and both regions can fail in ways that are visible to programs.
- RLIMIT_AS caps virtual address space. According to the Linux
getrlimit(2)manual, this resource limit constrains the size of the process’s virtual address space. - Allocation calls can return ENOMEM. When the limit is exceeded,
brk(),mmap(), andmremap()can fail withENOMEM. A failed allocation request from a program is reported this way, and the program must check for it. - Automatic stack expansion can fail. When the stack needs to grow and cannot, the access can generate
SIGSEGV. This is how a deep recursion or a large local array can crash a process even when heap memory is still available.
To check the limit on a shell session, run ulimit -v. A value of unlimited means no virtual address-space cap is set for that shell. Limits set by a service manager or container runtime can differ from your interactive shell, so check the environment the program actually runs in.
What’s actually slowing this PC down?
Pick the symptom - the matching free tool is one click away.
Comparing stack and heap
The table below compares the two regions on the axes the sources support. Cells marked “not stated” are points the cited sources do not establish, and you should not fill them in from assumption.
Best Value
- 100 DAYS OF ZERO PRESSURE — Decide at 100 days, not 30
- LOVE IT OR RETURN IT — Send it back within the trial. No questions
- 3 YEARS OF COVERAGE — Defects under normal use, year after year
- OUTLASTS THE REST — Others stop at one year. Yours goes for three
- REAL HELP, 24/7 — Midnight or Sunday, help is one message away
| Axis | Stack | Heap |
|---|---|---|
| Lifetime and ownership | Tied to function-call scope and call-frame lifetime (Kerrisk, 2026) | Tied to explicit dynamic allocation; lifetime is controlled by the program (Kerrisk, 2026) |
| Allocation and reclamation | Governed by call and return conventions defined by the ABI | Governed by allocator APIs, such as malloc() and free(), on top of brk() and mmap() (Linux man pages) |
| Size and growth constraints | Can fail when automatic expansion is refused, producing SIGSEGV; a fixed size is not stated in these sources |
Limited by address-space size and allocator limits, including RLIMIT_AS; a fixed size is not stated in these sources |
| Typical Linux mechanism | Automatic expansion of the stack region | brk()/sbrk() and mmap(), chosen by the allocator |
| Performance and locality | Not stated in these sources; compiler and register decisions affect generated code | Not stated in these sources; allocator design affects memory traffic |
| Implementation variability | Depends on ABI, compiler, runtime, and operating system | Depends on allocator, C library, and operating system |
The sources support the simplified storage roles, the Linux mapping and allocation mechanisms, the variability of layout, and the Linux address-space limits. They do not support universal performance differences between the two regions, so avoid claims that one is always faster.
A practical way to think about it
When someone asks “is this on the stack or the heap?”, the more useful question is which layer they mean. At the program level, the question is about lifetime and scope. At the process level, it is about which virtual mapping backs the address. At the CPU level, it is about which registers hold the addresses and state used to reach that memory. Those layers can disagree in a single function, and the answer depends on the compiler, the ABI, and the allocator in use.
Keep the stack and heap as names for behavior, not as physical locations. That mental model matches what the operating system and the CPU actually do.
Free tools Windows power users keep installed
One-click scans. No signup required.
Quick Recap
Product prices and availability are accurate as of the date/time indicated and are subject to change. Any price and availability information displayed on Amazon at the time of purchase will apply.
