Native 64-bit "Hello World" With NASM on FreeBSD

In yet another effort to fend off boredom, I tried to write a “hello world” in assembly, on FreeBSD 7.2/amd64. I wanted it to be a native 64-bit (more fun that way), so the developer’s handbook was not too helpful. And since by the logic of the Internet, there’s someone somewhere right now is looking exactly for this, I thought I’d share it here.

Aside: The Assembler used here is NASM. I grew up on 8085 and Z80, and find myself mentally exchanging the operands while reading gas-syntax assembly listings.

First off, the good old int 80h is not the way to make syscalls on the amd64. The SYSCALL instruction (see the Intel docs) is used instead. From the Intel docs, SYSCALL looks to be lighter and faster than an interrupt (should time it and compare sometime!). The SYSCALL clobbers RCX though, so libc saves RCX in R10 before the syscall. That implies that R10 is preserved by the SYSCALL. All this info was gathered from /usr/src/lib/libc/amd64/SYS.h. In case you haven’t installed /usr/src, you really should be doing it now.

The arguments passed seems to be in accordance with the (except-for-Windows-)standard 64-bit ABI (specs here), although I couldn’t find any documentation about this (!). The register RAX holds the syscall number. The full list of syscalls can be found at /usr/src/sys/kern/syscalls.master. Let’s see the ones we need to use:

1       AUE_EXIT        STD     { void sys_exit(int rval); } exit \
sys_exit_args void
4       AUE_NULL        STD     { ssize_t write(int fd, const void *buf, \
size_t nbyte); }

Armed with this info, we can now write our assembler source:

section .data

message:
    db      'hello, world!', 0

section .text

global _start
_start:
    mov     rax, 4
    mov     rdi, 1
    mov     rsi, message
    mov     rdx, 13
    syscall

    mov     rax, 1
    xor     rdi, rdi
    syscall

 

The first call sets RAX=4 to invoke write, RDI=1 being the file descriptor of standard output, RSI to the address of the message to write, and RDX=13 bytes to write. The syscall sets the carry flag on failure, so do a jb to catch errors.

The second call simply exits the process, RAX=1 corresponds to exit and RDI=0 is the exit code.

Assemble with:

~$ nasm -f elf64 -o p.o p.nasm

and then link with:

~$ ld -o p p.o

and have fun with:

~$ ./p
hello, world!~$ echo $?
0

 

Yeah, that looks good!

Some asides:

• _start is understood by ELF.
• The executable seems to have acquired a 2-byte .bss (?) and a 31-byte .comment section along the way. The comment contains "\x00The Netwide Assembler 2.05.01\x00". Couldn’t find any NASM command-line options or directives to turn this off. Not nice.
• Strip off the unwanted sections with "strip -R .comment -R .bss ./p" to reduce the executable size. It is now 536 bytes long. (If you liked that, you might find this interesting.)
• Is it possible to avoid ‘ld’ and get NASM to directly generate an executable ELF?

Heh. That was fun. Now let me quickly sneak out, grab lunch, watch a movie and get back to boredom.

About these ads