This article is aim to explain how to use assemble language realize those common function
in C. But I fail to get a simple method to introduce it because of some reasons . I will try to
extract some key point at this article. Then analysize a example in detail in next article.
( Of course, For those experienced guys, maybe a example is enough.)
/**
* How can we create local variable in a function?
*
* This is a interesting problem. First at all, what is the essence of a variable ?
* The answer is space,memory space. Recall the reason that we introduced the concept of
* the variable .we need those space to save some information. So,in fact, create a variable is
* equal to allocate some space.
*
* Now, the question is we should reside those variable in where ?
* Actually, we has been know something about global variable and static variable. They are
* arranged when compiled. But what about local variable ? where is it reside in ?
* Obviously,we can‘t arrange a special memory space for it when compile. Think about
* recursive function. If we specify a special memory space for a local variable, how can we
* ensure a function is reentrant. That will be awful, totally awful. So the conclusion is we
* can‘t reside the local variable in a absolute address, no matter where. It should be reside
* in a relative address. If we build a base address for every function call, then every function
* call will become independent. That is what we want theoretically. Actually, How can we
* build that frame ?
*
* Now, it is time to introduce a important design -- stack frame. It is helpful to realize
* our plan above. two special register, esp and ebp, was introduced to build a frame for a
* function. In addition, it provide a nice solution for function call, too.
*
* the emphasis of this frame is stack. It is building down. %ebp was used to point to
* the bottom of the frame .%esp was used to point to the top of frame. That means if we
* build a function like this:
* int func()
* {
* ....
* }
*
* we will get a frame like this
* 0xbfffe6a0 <-- %ebp
* ....
* 0xbfffe690 <-- %esp
*
* if there are some local variable in the function, just like this:
* int func( )
* {
* int a, b, c;
* }
*
* the frame maybe:
* 0xbfffe6a0 <-- %ebp
* 0xbfffe69c <-- c, 4 bytes
* 0xbfffe698 <-- b, 4 bytes
* 0xbfffe694 <-- a, 4 bytes
* <-- %esp
*
* we have been know how to create some local variable in assemble language.
*/
/*
* How can we call a function ?
*
* This seems like simple. From the view of machine, call a function is equal to change the
* flow of instructions, is equal to revise the value of register %IP.
* mov func,ip;
*
* but how can we return the caller ? maybe save the value of IP before revise is necessary
* . It seems we have two choice : save in a register, or save in the memory. Think about the
* current situation, register is still finite, and function call is infinite logically. So the memory
* will be a good choice.
*
* But where should be the place for those IP informations ? I thought we could allocate
* some memory space to build a special structure. It is used to save those information. Actually,
* a better way was introduced. see the following example, if we call a subroutine in main
* function:
* int main()
* {
* fun();
* }
* void fun()
* {
* ...
* }
*
*
* The value of pre-IP will be push into the stack and register %IP will be revise to the
* entry of fun function. the information will be saved like this.
* 0xbfffe6a0 <-- %ebp for main()
* 0xbfffe69c <-- var 2
* 0xbfffe698 <-- var 1
* 0xbfffe694 <-- var 0
* ....
* xxxxxxxx <-- return address
* <-- %esp for main()
*
* when we finish this subroutine, we could return the caller by pop the value into register %IP.
*/
x86的ABI（C函数实现原理）分析,布布扣,bubuko.com
原文地址：http://blog.csdn.net/u012301943/article/details/38144667
