A picture tells the thousand words:



In x86 systems, stack is growing to the bottom (shrinking to the top), while heap is in opposite direction.

But today I will just focus on stack. What is stack?



When we add parameters onto stack, the stack pointer decrements. We call it "push" operation.
But when we "pop" it off the stack, the stack pointer increments.
Stack is LIFO, also known as "last in first out"

Let take an example, in 32-bit, each parameter is 4 bytes.



The above push 2 DWORD parameters onto stack, then adjust the stack pointer to make it balanced.
Actually the above is the same like below:



After adding the "val1" and "val2" paramters onto stack, it is restored back to ebx and eax registers respectively, and the stack pointer is automatically adjusted if you use "push" and "pop", no need to increment or decrement stack pointer manually.
Look now, the last parameter, "val2" is restored back off stack first; meanwhile the first parameter, "val1" is restored back off stack the last, this is because it follows LIFO order, not FIFO (first in first out).

As a bonus, I will show how to do an alternative of "push" operation.



Now it reserves stack space of 4 bytes first, then store the "val1" parameter onto it.

Sometimes a program may reserves stack space of 32 bytes (multiple of 16) by doing like this:


Then it can do whatever it wants with the allocated stack.

To point to any of the 8 parameters ( 32/ 4 bytes = 8), it can then use ebp (points to the value of esp before allocating 32-byte stack space), or by referencing to esp directly:



This will copy first parameter pushed to stack (remember stack grows downward) to eax register.

I hope you enjoy this lesson, as what I learned in the past two years.

Disclaimer: Information herein is made accurate at the time of posting, however, corrections are welcomed, this article is written by me for LYN forum and my personal blog.

Unless otherwise stated, all content and picture are my own.


This post has been edited by MatQuasar: Jul 15 2023, 07:01 AM

The original post has been replaced with my own article.
If you still want to know the deleted post, it is about a cybersecurity competition: https://2023.cor.team/

Stack can used as temporary variable / parameters for call.

Beside push and pop,


Many CISC-type CPU designs, including the x86, Z80 and 6502,
have a dedicated register for use as the call stack stack pointer with dedicated call,

Full document link :
Stack (abstract data type) - Wikipedia
https://en.wikipedia.org/wiki/Stack_(abstract_data_type)

Stack vs heap comes out relatively common on our Go/Rust discussions esp when re:resource allocations.

https://medium.com/eureka-engineering/under...ry-9a2631b5035d

In general we want to avoid heap allocations for variable when stack allocation would work, to reduce Garbage Collection overhead. But that depends on the data structure.

It's ingrained enough that the built-in Go benchmarking includes tracking (heap) allocs/operation.

Nice to know about stack vs heap in Go. Thanks for pointing out, that article said large variables are stored in GC-heap. If I read correctly, it mentioned that it is slower if allocations are done on heap.

Of course. Allocs on stacks are just put stuff there, advance the stack pointer. Heap allocs you need to scan for the location of free space to use.

IMHO,

When people rely more on GC (since GC is designed to be more efficient / or there is no malloc option),
People may forget to properly allocate what / how much they need (use malloc and free wisely),
Rather than just use and throw away.

P/S : Languages' GC is introduced to solve malloc / free issues,
so they have to solve this problem, instead of creating problems for developer.





This post has been edited by flashang: Jul 15 2023, 10:50 PM

It will start on 7/29/2023 8:00:00 AM UTC+08:00

Currently ranked 265th, easy 1 point....

Ez.

(ok, the rest is harder)

Nice, you can make use of your discord bot!