How does the stack work in assembly language?

by

I think primarily you’re getting confused between a program's stack and any old stack.

A Stack

Is an abstract data structure which consists of information in a Last In First Out system. You put arbitrary objects onto the stack and then you take them off again, much like an in/out tray, the top item is always the one that is taken off and you always put on to the top.

A Programs Stack

Is a stack, it’s a section of memory that is used during execution, it generally has a static size per program and frequently used to store function parameters. You push the parameters onto the stack when you call a function and the function either address the stack directly or pops off the variables from the stack.

A programs stack isn’t generally hardware (though it’s kept in memory so it can be argued as such), but the Stack Pointer which points to a current area of the Stack is generally a CPU register. This makes it a bit more flexible than a LIFO stack as you can change the point at which the stack is addressing.

You should read and make sure you understand the wikipedia article as it gives a good description of the Hardware Stack which is what you are dealing with.

There is also this tutorial which explains the stack in terms of the old 16bit registers but could be helpful and another one specifically about the stack.

From Nils Pipenbrinck:

It’s worthy of note that some processors do not implement all of the instructions for accessing and manipulating the stack (push, pop, stack pointer, etc) but the x86 does because of it’s frequency of use. In these situations if you wanted a stack you would have to implement it yourself (some MIPS and some ARM processors are created without stacks).

For example, in MIPs a push instruction would be implemented like:

addi $sp, $sp, -4  # Decrement stack pointer by 4  
sw   $t0, ($sp)   # Save $t0 to stack

and a Pop instruction would look like:

lw   $t0, ($sp)   # Copy from stack to $t0  
addi $sp, $sp, 4   # Increment stack pointer by 4

More Related Contents:

  1. What is the direction of stack growth in most modern systems?
  2. Why does the x86-64 / AMD64 System V ABI mandate a 16 byte stack alignment?
  3. What is the function of the push / pop instructions used on registers in x86 assembly?
  4. What is an assembly-level representation of pushl/popl %esp?
  5. Does it matter where the ret instruction is called in a procedure in x86 assembly
  6. How exactly does the callstack work?
  7. What are CFI directives in Gnu Assembler (GAS) used for?
  8. Why does the x86-64 GCC function prologue allocate less stack than the local variables?
  9. Why is GCC pushing an extra return address on the stack?
  10. “enter” vs “push ebp; mov ebp, esp; sub esp, imm” and “leave” vs “mov esp, ebp; pop ebp”
  11. What are the ESP and the EBP registers?
  12. rsp doesn’t move when entering new function [duplicate]
  13. Is reserving stack space necessary for functions less than four arguments?
  14. how does push and pop work in assembly
  15. Boot loader doesn’t jump to kernel code
  16. Why does GCC allocate more space than necessary on the stack, beyond what’s needed for alignment?
  17. Stack allocation, padding, and alignment
  18. Where exactly is the red zone on x86-64?
  19. Why are rbp and rsp called general purpose registers?
  20. How to make the kernel for my bootloader?
  21. Why NASM on Linux changes registers in x86_64 assembly
  22. about assembly CF(Carry) and OF(Overflow) flag
  23. What do the brackets mean in NASM syntax for x86 asm?
  24. Why flush the pipeline for Memory Order Violation caused by other logical processors?
  25. Why does leave do “mov esp,ebp” in x86 assembly?
  26. Using ymm registers as a “memory-like” storage location
  27. Understanding %rip register in intel assembly
  28. How to tell the length of an x86 instruction?
  29. MIPS Assembly Alignment Align n
  30. Converting Int to Float or Float to Int using Bitwise operations (software floating point)

Leave a Comment