Printable View
Hi out there :)
Well, i got a problem in trying to understand what an "exit(1);" in the sourcecode _really_ does when the program is executed (on a Linux-box).
I read something about this exit(1) would only be a jump address on the stack. Is this right? If so, where exactly is it jumping to? How can I see this address (gdb?)?
May someone also could point me to some papers (english or german) that can answer these questions - I haven't found the good ones yet.
thank you all
regards
tim
> what an "exit(1);" in the sourcecode _really_ does when the program is executed (on a Linux-box).
It causes your program to stop, and return a status of 1 to the environment (usually your shell)
This you can inspect by typing
echo $?
(i think)
> I read something about this exit(1) would only be a jump address on the stack. Is this right?
Probably not
How it is implemented shouldn't really matter - as a programmer in C, you don't need to know such detail.
> If so, where exactly is it jumping to?
It might be a call to the operating system to say that the program has now finished.
Programs do not fall off the bottom of the stack, there is within the run time library an organised way of letting the OS know that the program has ended.
Actually, it is useful to know such information. Ignorance is the enemy of the professional developer because it forces you to make assumptions that are, more often than not, wrong.
Normally, when a program exits, it _does_ in fact reach the end of the stack-- that is the stack chain shrinks until the last address returns it to the loader. Once that is accomplished, the stackframe, zero-page information, jump and link info, application heap and process threads (including sub-processes) and thread-interrupts are disposed of (deallocated).
However, when you use the "exit()" call, to force a premature termination, you force a subsequent jump to the loader irregardless of what state the heap or stack is in. Then the above (previous paragraph) is performed to clean up everything prior to exit.
Enjoy.
Well, thanks a lot, I think this'll help me :)
But one more question: when having a closer look to the stack and its content, how can I find or recognize this jump address to the 'end of the stack'?
In fact 'the end' of the stack is at 0xffffffff but that's probably not what you meant, is it?
hum, sorry these questions may seem a bit strange, but I'm only trying to really understand what's going on there even (or especally) with the simple programs/functions/calls ect. :)
thx&cya
tim
It should be pointed out that a call to exit() causes the function registered by atexit() to execute (prior to process termination). The function _exit() does not bother with whatever may be registered by atexit().
This applies for POSIX systems; I can only speculate how Windows handles calls to exit().
There are two stacks.... the processor stack and the program stack for your app. The first address on the program stack is usually at the very end of your heap. stack grows down.
hm, can anyone point me to a _good_ text about the stack?
thx again
tim
"Assembly Language Step by Step" (Duntemann) does a good job of explaining the stack in both real and protected modes.
In my opinion, using exit() is a bad programming style. It is always possible to design your algorithms in such a way that things like exit() are not needed. The same for
Such things make your source very hard to read. In my opinion a program is best designed and most safe when it ends at the returning of the return value in the main().Code:void function (...)
{
...
if (condition)
return;
...
}
Code:int main (..)
{
....
return return_value;
}
I would like to point out that the function registered by atexit() is executed even when the main function executes return, not necessarily exit().
Hmmm, ironic. One of my lecturers always uses early returns as he HATES the else clause. But we suspect him of alcoholism, so...Quote:
Originally posted by Shiro
In my opinion, using exit() is a bad programming style. It is always possible to design your algorithms in such a way that things like exit() are not needed. The same for
Such things make your source very hard to read. In my opinion a program is best designed and most safe when it ends at the returning of the return value in the main().Code:void function (...)
{
...
if (condition)
return;
...
}
Code:int main (..)
{
....
return return_value;
}