From mboxrd@z Thu Jan 1 00:00:00 1970 MIME-Version: 1.0 In-Reply-To: References: Date: Mon, 16 Jan 2012 13:08:01 +0000 Message-ID: From: Charles Forsyth To: Fans of the OS Plan 9 from Bell Labs <9fans@9fans.net> Content-Type: multipart/alternative; boundary=00151740295c78323e04b6a4e7fb Subject: Re: [9fans] assembly syntax in plan 9 Topicbox-Message-UUID: 5d0fc994-ead7-11e9-9d60-3106f5b1d025 --00151740295c78323e04b6a4e7fb Content-Type: text/plain; charset=UTF-8 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 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 > > --00151740295c78323e04b6a4e7fb Content-Type: text/html; charset=UTF-8 Content-Transfer-Encoding: quoted-printable

You should read /sys/doc/asm.pdf first.=C2=A0
caref= ul: 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 regis= ter, that the loader implements
by replacing offsets relative to = it by the current appropriate offset from the hardware stack pointer regist= er (whatever
that might be on a given platform). That's esp on the x86. the TEX= T directive specifies the space a function
requires for its stack= frame, and the loader then adds appropriate code at start and end to provi= de 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 referen= ced to build the arguments for outgoing calls (but that space must
be accounted for in the TEXT directive).

(it&= #39;s probably not very different in effect from -fno-frame-pointer or what= ever it is for gcc,
which also doesn't use ebp except that is= implemented=C2=A0entirely by the compiler.)

On 16 January 2012 12:30, Alexander Kap= shuk <a= lexander.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 woul= d:
(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 poi= nter; e.g. movl %esp, %ebp
(3). then i would allocate space on th= e stack for local variables, if any; e.g. subl $n, %esp;
(4). the= n 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 programm= ing under plan 9; found some bits and pieces; e.g. in one of the posts it w= as mentioned that BP is a general purpose register, not the base pointer; a= nd that FP is what ebp is under unix/linux;

in the paper for the plan 9 assembler, it says that the= re are three registers available to manipulate the stack, FP, SP, and TOS; = would the following comparison stand true then?
plan9 =C2=A0 =C2= =A0unix/linux
------- =C2=A0 =C2=A0 -------------
FP =C2=A0 =C2=A0 =C2=A0 = =C2=A0EBP
SP =C2=A0 =C2=A0 =C2=A0 =C2=A0-4(%EBP)...-n(%EBP) /* lo= cal variables */
TOS =C2=A0 =C2=A0 ESP

t= hanks;

sasha kapshuk


--00151740295c78323e04b6a4e7fb--