What is the nasm assembly code version of gcc inline assembly

Question

I have this code which enables the cursor:

inline uint8_t inb(uint16_t port)
{
    uint8_t ret;
    asm volatile ( "inb %1, %0"
                   : "=a"(ret)
                   : "Nd"(port) );
    return ret;
}


static inline void outb(uint16_t port, uint8_t val)
{
    asm volatile ( "outb %0, %1" : : "a"(val), "d"(port) );
}


int main(void)
{
    outb(0x3D4, 0x0A);
    outb(0x3D5, (inb(0x3D5) & 0xC0) | 1);
    outb(0x3D4, 0x0B);
    outb(0x3D5, (inb(0x3D5) & 0xE0) | 2);
}

I want dont want to use inline assembly and wrote it in nasm assembly, however when using the assembly implementation of outb instead of inline assembly it wont enable the cursor correctly. The declaration for the nasm function:

extern void outb(uint16_t port, uint8_t val);

And the function:

outb:
    mov dx, di
    mov eax, esi
    out dx, al
    ret

Whats the problem?

Update: The function now looks like this but it still doesnt work:

outb:
    push ebp
    mov esp, ebp
        
    mov dx, word [ebp+2]
    mov al, byte [ebp+3]
    out dx, al
    
    mov esp, ebp
    pop ebp
    ret

What is your declaration for the nasm function in c++ ? the problem may be in how the parameters are passed to your asm function. — Michaël Roy, Feb 15 '21 at 20:27
You shoudl declare all external asm functions as extern "C". Parameter passing in c++ may vary depending on -O optilization parameter, or other compilation options. This imlplies function parameters to asm functions should be passed on the stack. — Michaël Roy, Feb 15 '21 at 20:45
why wouldn't you want to use inline assembler?! GCC can optimize inline assembler, but certainly can't do so with your external nasm function. — Antti Haapala -- Слава Україні, Feb 15 '21 at 20:46
Is this 32 or 64-bit code? The calling conventions are different. — Nate Eldredge, Feb 15 '21 at 20:47
@MichaëlRoy but this is C code, why should I use extern "C" ? — Earl of Lemongrab, Feb 15 '21 at 20:48
Also, since the inline assembler version *worked*, compile that to assembly `-S` and voilà, there's your assembler source code. — Antti Haapala -- Слава Україні, Feb 15 '21 at 20:48
Well yeah, you have to translate the syntax, but that's just a mechanical exercise. Or use `gcc -S -masm=intel` to get something much closer. — Nate Eldredge, Feb 15 '21 at 20:51
`-masm=intel`. For me it did produce `mov eax, esi; mov edx, edi; outb al, dx` though ... so idk ... — Antti Haapala -- Слава Україні, Feb 15 '21 at 20:51
Okay, then your `outb` is using the wrong calling convention. Its arguments won't be in the `edi/esi` registers, but rather on the stack, in the two dwords above the return address. — Nate Eldredge, Feb 15 '21 at 20:55
@EarlofLemongrab. I assumed it was c++, since the calling convention of your asm function is the c++ convention. C passes arguments on the stack unless optimized by the compiler, which must then have access to the source code of the target function. — Michaël Roy, Feb 15 '21 at 21:14
The offsets `ebp+2` and `ebp+3` are wrong. Maybe you're counting dwords instead of bytes? Draw yourself a diagram of the stack layout, keeping in mind that each argument is pushed as a 4-byte dword. You ought to end up with `mov dx, word [ebp+8]` and `mov al, byte [ebp+12]`. Of course, setting up a stack frame with `ebp` is unnecessary in the first place as you can access the arguments relative to `esp` as in Antti's answer. — Nate Eldredge, Feb 15 '21 at 21:19
Also the first `mov esp, ebp` is backwards and should be `mov ebp, esp`. — Nate Eldredge, Feb 15 '21 at 21:24
Yes this works, thank you. Regarding performance, maybe when interfacing with c it is slower than inline asm, but if I have lots of self written code in asm isnt it generally faster than optimized c? — Earl of Lemongrab, Feb 15 '21 at 21:26
See https://stackoverflow.com/questions/577554/when-is-assembly-faster-than-c?rq=1. The short answer is "maybe a little bit faster, if you really know what you're doing, but only rarely to an extent that it is worth the time spent writing and debugging it". — Nate Eldredge, Feb 15 '21 at 21:32
And I mean, no offense, but you just spent about an hour trying to debug a function that's only four lines long. Think of what it would take to deal with "lots of self written code". — Nate Eldredge, Feb 15 '21 at 21:34

Antti Haapala -- Слава Україні · Answer 1 · 2021-02-15T21:03:57.243

3

Your code is correct for 64-bit SYSV ABI. Arguments are passed in EDI and ESI registers:

outb:
        mov     eax, esi
        mov     edx, edi
        outb dx, al
        ret

But in 32-bit ABI they're passed on stack:

outb:
        mov     edx, DWORD PTR [esp+4]
        mov     eax, DWORD PTR [esp+8]
        outb dx, al
        ret

But this also shows the problem with not using inline assembler - your arguments must now be pushed on stack and they must be popped too, whereas if you used the GCC inline assembly the compiler would just need to emit the outb instructions inline interleaved with only stuff that places correct values into al, dx - and your code will be much more performant.

edited Feb 15 '21 at 21:03

answered Feb 15 '21 at 20:59

Antti Haapala -- Слава Україні

129,958
22
279
321

Make it `out dx, al` for Intel syntax. – Nate Eldredge Feb 15 '21 at 21:00
@NateEldredge oops you're right, I wonder why it bugs like that :D – Antti Haapala -- Слава Україні Feb 15 '21 at 21:02
1

OP wrote their inline asm for AT&T syntax but godbolt defaults to `-masm=intel` which breaks it. – Nate Eldredge Feb 15 '21 at 21:03

score 0 · Answer 2 · answered Feb 15 '21 at 21:55

The NASM equivalent of static inline void ... is a macro, not a function you actually call. The C compiler will inline it to a single out instruction with the inputs in registers (or as an immediate, that's what the "N" constraint allows, with "d" allowing the DX register.)

Actually setting up a function call would be more trouble than just writing an out instruction.

That macro should probably just be an out instruction (no mov overhead), with maybe %ifnidn string processing and a %if numeric condition to verify that the port number is the string dx or a number from 0..255, and that the 2nd operand is al. (See the manual for the limitations on the forms.)

Or just use out directly like a normal person; in C the reason for wrapping it is to hide the inline-asm noise, but that doesn't apply in pure asm. Using a macro is more likely to just make things more difficult (by stepping on other registers if you don't limit it to just an out instruction).

In NASM, the operand-size for out is implied by the register you use: you can't write outb, just out 0x80, al or out 0x80, ax or whatever. outb is an error.

What is the nasm assembly code version of gcc inline assembly

2 Answers2