You should read /sys/doc/asm.pdf first. 

careful: TOS is only for 68k. nothing else defines or uses it.

Plan 9 doesn't use a base pointer, because everything can be addressed relative to the stack pointer,

and the loader keeps track of the SP level. thus FP is a virtual register, that the loader implements

by replacing offsets relative to it by the current appropriate offset from the hardware stack pointer register (whatever

that might be on a given platform). That's esp on the x86. the TEXT directive specifies the space a function

requires for its stack frame, and the loader then adds appropriate code at start and end to provide it.

0(FP) is the first argument, 4(FP) is the second, and so on. 0(SP) is the bottom of the current frame,

and 0(SP), 4(SP) etc are referenced to build the arguments for outgoing calls (but that space must

be accounted for in the TEXT directive).

(it's probably not very different in effect from -fno-frame-pointer or whatever it is for gcc,

which also doesn't use ebp except that is implemented entirely by the compiler.)

On 16 January 2012 12:30, Alexander Kapshuk <alexander.kapshuk@gmail.com> wrote:

i have a question about putting things on the stack for x86 arch under plan 9...

under unix/linux, when defining a function, i would:

(1). push the address the base pointer is pointing to prior to this function being called, onto the stack; e.g. pushl %ebp

(2). then i would have the base pointer point to the current stack pointer; e.g. movl %esp, %ebp

(3). then i would allocate space on the stack for local variables, if any; e.g. subl $n, %esp;

(4). then follows the function body;

to return from the function i would:

(1). restore the stack pointer; e.g. movl %ebp, %esp;

(2). restore the base pointer, e.g. popl %ebp;

(3). then return to the calling function;

i searched the 9fans archives for posts on assembly programming under plan 9; found some bits and pieces; e.g. in one of the posts it was mentioned that BP is a general purpose register, not the base pointer; and that FP is what ebp is under unix/linux;

in the paper for the plan 9 assembler, it says that there are three registers available to manipulate the stack, FP, SP, and TOS; would the following comparison stand true then?

plan9    unix/linux

-------     -------------

FP        EBP

SP        -4(%EBP)...-n(%EBP) /* local variables */

TOS     ESP

thanks;

sasha kapshuk