x86 assembly program to compute some random function

Question

As a way to refresh my knowledge on assembly, I tried to compile the below C program to x86 assembly by hand.

#include <stdio.h>

long f(long a, long b, long c, long d, long e, long f, long g, long h) {
    long xx = a * b * c * d * e * f * g * h;
    long yy = xx + 1;
    long zz = yy * 2;
    return xx + yy + zz;
}

int main() {
    printf("%d", f(3, 4, 5, 6, 7, 8, 9, 10));
    return 0;
}

Here is the corresponding assembly program:

; nasm -f elf64 test.asm && gcc -no-pie -fno-pie -o test test.o && ./test

        bits    64
        global  main
        extern  printf
        extern  exit

        section .text
f:
        push    rbp
        mov     rbp,      rsp
        sub     rsp,      24
        push    r12
        push    r13
        mov     r12,      rdi
        mov     r13,      rsi
        imul    r12,      r13
        mov     rax,      r12
        imul    rax,      rdx
        imul    rax,      rcx
        imul    rax,      r8
        imul    rax,      r9
        imul    rax,      [rbp+24]
        imul    rax,      [rbp+32]
        mov     [rbp-8],  rax
        add     rax,      1
        mov     [rbp-16], rax
        imul    rax,      2
        mov     [rbp-24], rax
        mov     rax,      [rbp-8]
        add     rax,      [rbp-16]
        add     rax,      [rbp-24]
        pop     r13
        pop     r12
        add     rsp,      24
        pop     rbp
        ret
main:
        mov     rdi,      3        ; arg 1
        mov     rsi,      4        ; arg 2
        mov     rdx,      5        ; arg 3
        mov     rcx,      6        ; arg 4
        mov     r8,       7        ; arg 5
        mov     r9,       8        ; arg 6
        mov     rax,      9
        push    rax                ; arg 7
        mov     rax,      10
        push    rax                ; arg 8
        sub     rsp,      8        ; stack alignment procedure (call will add extra 8 bytes)
        call    f                  ; the return value will be in rax
        add     rsp,      24       ; remove arg 7 and arg 8 from the stack (and the extra space from stack aligment)
        mov     rdi,      fmt      ; arg 1
        mov     rsi,      rax      ; arg 2
        xor     rax,      rax      ; since printf is varargs, so we need to clear rax
        call    printf
        mov     rdi,      0        ; arg 1
        call    exit

        section .data
fmt:    db      "%d", 10, 0        ; "%d\n\0"

(I am using Linux-based machine to run this program.)

There are no errors with this program (I hope!) and it produces the same output as the original C code.

I am wondering what are possible ways I can improve my assembly code (i.e. making it faster and safe). I believe I can write the function f in a better way: use less registers and mov instructions. There are some things I am uncertain:

I am not sure whether I aligned the stack pointer correctly before each call instruction. I believe I did so.
I ended the program by making call to exit function. I am not sure if it is the best way to do it.

Other suggestions are welcome!

Please do not edit the question, especially the code, after an answer has been posted. Changing the question may cause answer invalidation. Everyone needs to be able to see what the reviewer was referring to. What to do after the question has been answered. — pacmaninbw
– pacmaninbw ♦, Commented May 7, 2024 at 23:14
@pacmaninbw actually, I was trying to fix an error in my program that went unnoticed. This error was not mentioned in the answer. — The Rizzler
– The Rizzler, Commented May 7, 2024 at 23:21

user555045 · Accepted Answer · 2024-05-07 15:47:23Z

I am not sure whether I aligned the stack pointer correctly before each call instruction. I believe I did so.

For the call to f, I believe you did. But that's the least important one: it would have worked regardless.

By the way instead of sub rsp, 8 you could do a dummy push, just push any register, that's smaller in terms of code size and may avoid some stack pointer synchronization µops. As quoted from Agner Fogs microarchitecture document:

The modification of the stack pointer by PUSH, POP, CALL and RET instructions is done by a special stack engine, which is placed immediately after the decoding stage in the pipeline and probably before the μop cache. This relieves the pipeline from the burden of μops that modify the stack pointer. This mechanism saves two copies of the stack pointer: one in the stack engine and another one in the register file and the out-of-order core. These two stack pointers may need to be synchronized if a sequence of PUSH, POP, CALL and RET instructions is followed by an instruction that reads or modifies the stack pointer directly, such as ADD ESP,4 or MOV EAX,[ESP+8]. The stack engine inserts an extra stack-synchronization μop in every case where synchronization of the two stack pointers is needed.

Those stack-synchronization μops are usually not a big deal, but if you can avoid them for free, you may as well.

For printf the alignment may actually matter but after add rsp, 24 the alignment is off again, and there is nothing after that to restore it. By the way, it is more usual in x64 code to allocate some stack space once in the function prologue and then don't change rsp in the function body (except by the call instruction), unlike 32-bit x86 where it was common to do pushes and pops and add esp, 24 etc randomly throughout the function body (not really random, but you get the point).

For f you have some stack manipulation, that's fine but it's a leaf function so (depending on the registers used etc) it may be possible to avoid that. As a point of comparison, GCC managed to produce this code:

f(long, long, long, long, long, long, long, long):
        imul    rdi, rsi
        imul    rdi, rdx
        imul    rdi, rcx
        imul    rdi, r8
        imul    rdi, r9
        imul    rdi, QWORD PTR [rsp+8]
        imul    rdi, QWORD PTR [rsp+16]
        lea     rax, [3+rdi*4]
        ret

Which I think is quite nice, for a compiler. (for a human, I'd probably expect them to chop up that long dependency chain through all the imul a bit to lower the latency, there's no downside)

You don't need to save r12 and r13 if you don't modify them, and you can avoid modifying them. For xx and yy it seems like you need them twice so I understand that you save them (you could have copied them to other registers though, that's generally preferred over saving them to the stack). Writing xx + yy + zz in terms of xx, we get (xx + (xx + 1)) + ((xx + 1) * 2) which simplifies to 4 * xx + 3, which is what GCC has done with lea on the second to last line. That avoids some complexity, and also lets it move the result to rax for free as a bonus.

I ended the program by making call to exit function. I am not sure if it is the best way to do it.

That's OK. Alternatively, since you're in main (as opposed to writing your own entrypoint, commonly called _start) you can also just return.

Stack Exchange Network

x86 assembly program to compute some random function

1 Answer 1

You must log in to answer this question.

Hot Network Questions

x86 assembly program to compute some random function

1 Answer 1

You must log in to answer this question.

Related

Hot Network Questions