Hey Everyone, I am Vikram Salunke
and welcome to the x86 Assembly
this is Video number 28 and Part 3
of Local Variables and Arguments Passing
In this video we will see the remaining part
of C program in a Visual Studio
so, let's get started.
Now we are executing from function()
first the function() will set it's stack frame onto the Stack
so the function() will be needing EBP to point it's
stack frame
but currently EBP containing the main()'s
stack frame pointer
and we want to save that stack frame pointer
because function() is returning to main()
and it's function()'s responsibility
to give back main() it's own stack frame pointer back
so that' why the value from the EBP will get
push onto the stack
so the first instruction is push ebp
step into that
so the value from ebp got pushed
onto the stack
now from this point
i.e. 0012FF4C the function's stack frame
begin onto the stack
and we saw earlier
function() will need ebp to point it's
stack frame pointer
so the value from the esp i.e. 0012FF4C
will get move into the EBP
step into that
and that got done
so now EBP pointing to the function()'s
stack frame
and that is 0012FF4C
and from this address it will be all
function()'s stack frame
and in this stack frame
the function will save it's local variables,
it's registers etc.
as we saw earlier in the C program
the function() has 4 variables
int x, int y, int var1 and int var2
and for that it will need 16 bytes onto the stack
and 10h represents 16 into the hexadecimal format
to save all those 4 variables onto the stack
10 will get subtract from esp
and space will get allocate to store 4 variables
onto the stack
currently, esp is pointing to the 0012FF4C
and we will minus 10 from that
step into that
as we can see 10 got minus from esp
now C statement is arg1 will be moved into int x
for that value pointed by arg1 will get move into eax first
and after that eax will get move into the
address pointed by ptr x
so let's step into that
now eax contains value pointer by ptr arg1
next instruction is
eax will get move into the address pointed by ptr x
let's step into that
now eax got moved into address pointed
by ptr x
next instruction is arg2 will get copied into int y
for that value pointed by ptr arg2
will get move into ecx
and after that ecx will get move into address
pointed by ptr y
let's execute that
step into that
now ECX contains the value pointed by ptr arg2
and next instruction is ecx will get move into
the address pointed by ptr y
let's step into that
so the address pointed by ptr y was
0012FF48 and the value from
the ECX got moved into that address
next C statement is
program is defining new variable int var1
and setting value 3
for that 3 will get move into address pointed
by ptr var1
let's step into that
ok, 00000003 got moved into address pointed by var 1
next C statement is there is
new variable int var2
and that variable has a value 4
and the assembly equivalent is
4 will get moved into the address pointed by ptr var2
let's step into that
now 00000004 has moved into
address pointed by ptr var2
now function() is returning with var2
and as we have seen in a cdecl video
EAX register is responsible
to store the return value
so, the value pointed by var2
will get move into the eax
let's step into that
now EAX contains 00000004
because that is value of var2
now function() is ending here
and as we saw earlier
the function is responsible to clean up
it's own stack frame
for that value from ebp will get move into the esp
now just imagine esp is somewhat here
and ebp is here
and this is function()'s stack frame
and now function() is returning
so function() needs to clear this space
for that what it will do?
it will point the ESP to the EBP
and automatically those
stack will get clear
let's step into that
now ESP has moved to the 0012FF4C
and that is a value of a ebp
now when one function returns to another function
it has to give back
old function()'s stack frame pointer back
in this case
function() is returning to main()
and when we started function()
we saved, main()'s stack frame pointer onto the stack
and now we will pop
that stack frame pointer back to the EBP
let's step into that
that got popped
after that function() will return to main()
and when function() will return to main()
it will take the return address
saved by the main()
and that is 00401051
and that will get move into EIP
and EIP will begin execution from 00401051
let's step into that
now EIP is returned to the 00401051
and we are executing from main()
now main() passed 2 int variables
as an argument form to the function()
so, as we saw in a cdecl video
it is a caller's responsibility
to clean up it's own stack frame
and in this case
main() is a caller and function() is a callee
to clean up the stack
8 bytes will get add into the ESP
and those 00000001 and 00000002
which passed as an argument form
will get clear from the stack
let's step into that
that got done
and now ESP is pointing 8 bytes below
and that means those values
got automatically cleared from the stack
and as we saw earlier the value returned
by the function() will get saved
into the new variable
known as int value
eax contains the return value
from a function()
and we will save that into the address pointed by value
let's step into that
the return value got stored
onto the address pointed by value
now main() is returning with 0x11111111
for that those 0x11111111 will get move
into the eax
let's step into that
those 11111111 got moved into the EAX
and now main() is ending here
main() has some local variables
it will use the same trick
which we saw in a function()
that EBP is pointing at stack frame pointer
and ESP is pointing at top of the stack
and it has some local variables and registers
now to clean up the stack
ESP will be moved to EBP
and automatically those value
will be get cleared
step into that
as we can see the local variables
got cleared from the stack
next instruction is pop ebp
we are giving back stack frame pointer
of a function who called main()
now EBP contains the stack frame
pointer of a function who called main()
and now main() is returning
main() will return to the
function who called it
for that it will take the
value from the stack
i.e. 00401328
and it will put that value into EIP
and EIP will begin execution from there
let's step into that
as we can see
we have returned to that address
but this is beyond our scope of program
so we will stop here
so, that's it for this video
I am trying to explain as easy as possible
still if you have any further doubts
you can contact me on following hadles
in the next video
we will see the same C program
but in an animation format
do watch that video
then your understanding will get more clearer
Thank you :)
For more infomation >> A NOITE ESCURA DA ALMA E SUAS CONSEQUÊNCIAS LUMINOSAS - (MÃE MARIA) - Duration: 10:01. 
For more infomation >> The Good Place - Did Michael Dupe Them Again? (Episode Highlight) - Duration: 2:24. 
For more infomation >> head&shoulders グローバル ビーチプラスチック プログラム - Duration: 1:01. 
For more infomation >> COVER LAGU BATAK 'MARDUA HOLONG OMEGA TRIO' Versi INDONESIA AKUSTIK - Duration: 4:01. 
For more infomation >> THE FALL | STAY A LIVE #1 w/trickydickie - Duration: 2:35:53. 
Không có nhận xét nào:
Đăng nhận xét