x86 Assembly set of 'push'es and 'pusha' difference

Question

I was told to put valid registers into stack not to overwrite them later in "subprogram" and it's clear to me, everyone knows it. But when I read the code of my mates I found the following code:

puts: ; display character in ax
        push ax
        push bx
        push cx
        push dx
        mov dx, ax
        mov ah, 9h
        int 21h
        pop dx
        pop cx
        pop bx
        pop ax 
        ret

Then I saw pusha and popa commands. I suppose it could be done this way:

puts: ; display character in ax
        pusha
        mov dx, ax
        mov ah, 9h
        int 21h
        popa
        ret

Is there any difference between the pusha and set of pushes? Thank you in advance.

Beware that `pusha` and `popa` are 80286+ instructions. If you are targetting a plain 8086 machine, these won't work. In fact, some assemblers might need the `.286` directive in order to recognize them as valid instructions. — mcleod_ideafix, Apr 19 '15 at 09:59
Isn't using .286 (dot directive) considered as bad practice? — Bartłomiej Szałach, Apr 19 '15 at 22:25
@mcleod_ideafix : `pusha` and `popa` were introduced in the 80186 so you'd also be able to use `.186` — Michael Petch, Aug 09 '20 at 16:02
So what were those opcodes doing on older CPUs? Were there some other instructions at these positions of the opcode table? Or the processor just did some random stuff or maybe hanged? — SasQ, Sep 19 '20 at 20:32

Guffa · Answer 1 · 2015-11-17T23:09:54.523

6

The pusha operation pushes more than the ax, bx, cx and dx registers:

"Pushes all general purpose registers onto the stack in the following order: (E)AX, (E)CX, (E)DX, (E)BX, (E)SP, (E)BP, (E)SI, (E)DI. The value of SP is the value before the actual push of SP."

You can do basically the same by pushing the registers using eight push instructions, but that will push a different value for sp. You can simply omit the stack pointer as there is actually no need to push it. Pushing and poping the seven registers fills the same purpose as pusha and popa even if it doens't do exactly the same thing:

push ax
push bx
push cx
push dx
push bp
push si
push di
...
pop di
pop si
pop bp
pop dx
pop cx
pop bx
pop ax

edited Nov 17 '15 at 23:09

answered Apr 19 '15 at 09:46

Guffa

687,336
108
737
1,005

I know it saves more register, but can it be replaced in the given example? – Bartłomiej Szałach Apr 19 '15 at 09:47
2

@onegrx Yes, as long as you replace the `pop`s with `popa` as well. :) – Daniel Kamil Kozar Apr 19 '15 at 09:47
2

@onegrx: You can't replicate the exact behavoir of `pusha` and `popa` with just `push` and `pop` instructions, but you can fulfill the same purpose. – Guffa Apr 19 '15 at 09:59
1

`pusha` is much shorter though (1 byte for `pusha` vs. 8 bytes for a series of individual `push`es). Might be relevant in some tight code, e.g. a bootloader or a BIOS routine on a small ROM. – SasQ Sep 19 '20 at 20:42

score 6 · Accepted Answer · edited Jun 20 '20 at 09:12

Yes, pusha and popa are functionally equivalent, if only because they push/pop all registers. However, is it necessary to do so for a simple DOS Interrupt call?

Transferring to an Interrupt Routine
...

It is the responsibility of the interrupt routine to restore any registers it uses
(http://www.shsu.edu/csc_tjm/spring2001/cs272/interrupt.html)

As with all operations, do as much as is needed and nothing more. An interrupt call must preserve registers - apart from the ones that are documented to change. Regular status calls return their result in AX and may change the flags, and change nothing else. If an interrupt changes anything else (ds:dx, for example), it should be stated so in its documentation.

In your code, using ah=09 / int 21, the only change is

Return: AL = 24h

and so all other registers can safely be assumed "stored".

There is a reason an interrupt preserves as much as possible. Globally, an interrupt (the "real" ones, not the user-invoked) may happen any time while other code is running.

There is also a good reason not to use pusha/popa indiscriminately. Your stack has a limited size -- sure, it's large, but so is the number of routines that can be nested. And in 32- and 64-bit code the registers are way larger as well.

Every single routine should preserve only those registers that are known to change, and mirroring that, you should only save the ones you will need later before you call such a routine. In the example code there are none, so you can safely remove all pushing and popping.

Who is the Tim McGuire you're quoting? Is the 14 years old article reliable? — xmojmr, Apr 19 '15 at 14:28

score 1 · Answer 3 · answered Apr 19 '15 at 09:46

1

pusha saves some more registers, notably the value of sp before executing, bp, si, and di. Other than that, the behaviour is pretty much identical.

answered Apr 19 '15 at 09:46

Daniel Kamil Kozar

18,476
5
50
64

x86 Assembly set of 'push'es and 'pusha' difference

3 Answers3