Hey Everyone, I am Vikram Salunke
and welcome to the x86 Assembly
This is video number 30
and part number 5 of Local Variables
and Arguments Passing
In this video we will continue
our execution of in animation format
so, let's get started
we are executing from function()
now function() needs to start it's own stack
frame pointer onto the stack to save
it's local variables, registers etc.
and EBP always point to the stack
frame pointer
currently, EBP is pointing at
0x0012FF68
that is a main()'s stack frame
first we will save that on to the stack
for that we will push ebp
that got pushed onto the stack
next instruction is move esp into ebp
currently, esp is pointing at
0x0012FF4C
and EBP will be move there
and from this point it will
all function()' stack frame
now let's analyze our stack
this is a function()'s stack frame
this is a main()'s stack frame
and it contains main()'s local variables,
registers, arguments that needs to
pass to the function() etc.
and this is a initialization function()'s
stack frame
who called main()
now as we can see
our viewing area is full
we will only see stack from this point
and I will hide these elements
and when we will return to the main()
I will show these elements
ok, let's see stack
from only this point
now next instruction is subtract
10 from esp
as we can see function() has
4 variables
int x, int y, int var1, int var2
and for that function() needs to
reserve space onto the stack
and decimal value of a 10 is 16
we need to allocate 16 bytes onto
the stack because each int variable
4 bytes
for that we will need to subtract 10
from ESP
currently ESP is at 0x0012FF4C
let's execute that
ok, space got allocated for
4 variables onto the stack
next, main() is saving arg1 into int x
for that, value pointed by arg1
will get move into eax first
that got done
next that eax will get move into
address pointed by ptr x
that got done
next, function() is saving arg2 into y
for that value pointed by ptr arg2
will get move into ecx
that got done
next that value of ecx
will get move into the address
pointed by ptr 7
let's do that
it got moved
next, function() is defining
new variable int var1 = 3
for that 3 will get moved into
address pointed by var1
let's do that
next function() is declaring
new variable int var2 = 4
for that 4 will get move into
address pointed by ptr var2
let's do that
it got moved
next function() is returning
with the var2
and as we saw in cdecl video
eax register contains
the return value
so, the value pointed by var2
will get move into eax
the value pointed by var2 is
0x00000004 that will get move
into EAX
that got done
now, function() is ending here
and as we can see the function()
has some data onto the stack
and function() is responsible
to clear up this data
to clear up this data
the value of EBP
will get moved into ESP
and those four will automatically
get cleared from the stack
let's execute that
EBP is at 0x0012FF4C
that value will get move into ESP
and ESP is now at 0x0012FF4C
and the data got cleared from the stack
now, as we can see
function() is returning to main()
and we will need main()'s
stack frame
so let's get back main()'s data
it is main()'s stack frame
now function() is returning to main()
first, function() will give back
main()'s stack frame pointer back
and main()'s stack frame is 0x0012FF68
that will get popped into EBP
and EBP will point there
ok, we popped the top of the stack
and we put that into EBP
and as we can see,
now EBP contains main()'s stack frame pointer
the next instruction is return instrunction
to execute return instruction,
the return address pointed by ESP will be
put into EIP
and EIP will continue execution from there
the address pointed by ESP
is 0x00401051 will put that into EIP
and EIP using that address
will return to the main()
we have returned to the main()
using the same return address
which we took from the stack
and now we will start the execution from main()
the fist instruction is add 8 into esp
now as we saw earlier
main() passed 2 arguements
to the function()
so, it is main()'s responsibility
to clear those from the stack
because as we saw in a cdecl video
the caller is responsible
to clean up the stack
and in this case
main() is caller and function is callee
the Decimal value of 8 is also 8
we will take the ESP
i.e. 0x0012FF54
we will add 8 bytes into it
and the address which we will get
is 0x0012FF5C
which is here
so using this logic
main() will clear these two elements
from the stack
let's execute that
so, we cleared these two elements
from the stack
next instruction is
move eax into the address pointed by ptr value
let's recall
when main() called function()
it passed two arguments 'a' and 'b'
and now main() is saving the result
into the int value
which passed by the function()
and as we all know
the EAX register contains the return value
so, we will save
that into the address pointed by ptr value
EAX contains 0x00000004
i.e. return value which returned
from the function()
and now it got moved into
address pointed by value
next, main() is returning with
0x11111111
for that those 0x11111111 will get moved into EAX
now EAX contains 0x11111111
main()'s return value
now main() is ending here
so, it is main()'s responsibility
to clear up this stack
how the stack will get clear?
for that value of ebp will get move into esp
value of a ebp is 0x0012FF68
currently, ESP is pointing at the
0x0012FF5C
and when the value of a EBP
will get moved into ESP
ESP will point at 0x0012FF68
and that's how these space will get clear
let's execute that
ok, by moving ebp into esp
main() cleared it's stack frame
next instruction is pop ebp
that means top of the stack
will get popped into EBP
currently, top of the stack is
0x0012FFB8
that value will get popped into EBP
and EBP will point at 0x0012FFB8
why we are doing this?
because main() is returning to the function()
who called it
and we call that function 'Initialization function'
it is main()'s responsibility
to give back the calling function
it's own stack frame pointer back
let's execute that
ok, currently now EBP
is pointing at the 0x0012FFB8
and that is stack frame pointer
of a initialization function
who called main()
next, main() is returning
for that the top of stack
i.e. 0x00401328 will be moved
into the EIP
and EIP will begin execution from there
the value 0x00401328
it is a return address
of a function who called main()
let's execute that
ok, main() is returned to that function
and EIP will now start execution from
00401328
we will stop our execution here
because this is beyond our scope
of a program
that's it for this video
I hope you understood
everything clearly
if you have any suggestion,
any feedbacks
do write me on vikram@vmaskers.com
it motivates me to make new videos
for you guys
Thank you :)
For more infomation >> "CODEX DEVELO YA EU" - MENSAGEM DE ZERO I - Duration: 11:03. 
For more infomation >> COVER LAGU 'Armada'Asal Kau Bahagia versi Batak - Duration: 4:02. 
For more infomation >> Reiki Divino - Aula 8 - Nível 1 - Duration: 9:26. 
Không có nhận xét nào:
Đăng nhận xét