Assembly Language Stack and Subroutine

Question

I'm really confused as to how stack pointers and byte pointers work. Here is the segment of code the problem is referencing:

    .data
v1  db  'AB'
v2  db  'CD'
v3  db  'EF

    .code
start:
     mov  ax,@data
     mov  ds,ax
     mov  sp,0100h

;call the subroutine
     mov  ax,offset v1
     push ax
     mov  ax,offset v2
     push ax
     call subr
retsub:

The subroutine is:

subr:
     push bp
     mov  bp,sp
     mov  si,[bp+6]
     add  si,1
     mov  dl,[si]
     mov  ah,2
     int  21h
     pop  bp
     ret

The three review questions associated with this problem have these answers:
1. After mov bp,sp in the subroutine, the value of the hex value in bp is 00F8.
2. The subroutine writes a single ASCII character to the standard output. It writes B.
3. The hex value in the sp register after the subroutine returns to the main program at the instruction at the label retsub is 00FC.

Can anyone walk me through the steps so that I can understand this process a little better?

The offset data table that I have is:

offset  00  01  02  03  04  05
data    41  42  43  44  45  46

The way that I approach this problem in my head is:

mov  sp,0100h      ;sp = 0100
mov  ax,offset v1  ;ax = 4142
push ax            ;4142 is pushed onto the stack
mov  ax,offset v2  ;ax = 4344
push ax            ;4344 is pushed onto the stack
call subr

stack
------
|4344|
------
|4142|
------

This is as far as I understand and I'm sure I'm not even doing this part right. If you can, please break it down with what bp and sp is with each step so that I can follow along and hopefully apply this to another review problem.

Btw, you don't need to load SS or SP explicitly at the beginning of .COM and .EXE programs. DOS takes care of loading SS:SP. Further, the stack size should be set with the appropriate stack segment definition or special keyword (if there's any supported by the assembler). ESP should not be loaded with an arbitrary hard-coded value, there must be space reserved for he stack. — Alexey Frunze
– Alexey Frunze, Commented Dec 13, 2011 at 9:02

Alexey Frunze · Accepted Answer · 2011-12-13 08:56:44Z

3

Every push decrements sp by the size of the pushed element. Every pop increments sp similarly.

So, you begin with sp = 100h, then you

subtract 2 with push ax
subtract 2 with push ax
subtract 2 with call subr because call pushes the return address and it's 16-bit here
subtract 2 with push bp and arrive at sp = 0F8h
add 2 with pop bp
add 2 with ret and remove the 16-bit return address and arrive at sp = 0FCh

answered Dec 13, 2011 at 8:56

Alexey Frunze

62.3k14 gold badges90 silver badges190 bronze badges

Sign up to request clarification or add additional context in comments.

Comments

Ville Krumlinde · Accepted Answer · 2011-12-13 09:19:49Z

1

After mov bp,sp in the subroutine, the value of the hex value in bp is 00F8

Yes, because sp is initialized with 100h then two word sized arguments are pushed (push ax), the subroutine is called which pushes the 2-byte return address onto the stack, and last push bp is executed which decrease sp with another 2 bytes. So we have 100h-2-2-2-2 = 00F8h. Stack grows downwards in memory on Intel CPUs.

The hex value in the sp register after the subroutine returns to the main program at the instruction at the label retsub is 00FC.

This is because the subroutine exits with a "pop bp" instruction, then a ret instruction which pops (read from and increase sp) an return address from the stack. So 00F8+2+2=00FC.

edited Dec 13, 2011 at 9:19

answered Dec 13, 2011 at 8:41

Ville Krumlinde

7,1711 gold badge36 silver badges41 bronze badges

3 Comments

Alexey Frunze Over a year ago

I don't see the FAR keyword anywhere (neither in the call instruction, nor in the ret instruction and there's no PROC), so the return address is 2-byte-long. The other 2 bytes come from push bp.

Ville Krumlinde Over a year ago

Alex, you are correct. I was too quick in replying and did not think it through correctly. I've edited my answer and +1 yours.

raphnguyen Over a year ago

Thanks, I think I understand the stack increment/decrement. I'm still a bit lost with indirect addressing and can't follow along with the code enough to know what it prints.

Collectives™ on Stack Overflow

Assembly Language Stack and Subroutine

2 Answers 2

Comments

3 Comments

Your Answer

Hot Network Questions

Collectives™ on Stack Overflow

2 Answers 2

Comments

3 Comments

Your Answer

Sign up or log in

Post as a guest

Related