it is available on both Linux and other operating systems (DOS/Windows) and its syntax is pretty close to MASM and could be easier to read/code than GAS.
1. As our first example let's write a program that outputs a message on console:
; hello.s section .text global _start ; required for linker (ld) _start: ; entry point mov edx,len ; string length mov ecx,mes ; string to write mov ebx,1 ; file descriptor (stdout) mov eax,4 ; syscall number (sys_write) int 0x80 ; call kernel mov eax,1 ; syscall number (sys_exit) int 0x80 ; call kernel section .data mes db 'Hello, NASM!', 0xa, 0 ; null terminated string to be printed len equ $ - mes ; length of string
Essentially we move string to ecx, its length to edx register, file descriptor
to be used for output in ebx and Linux sys_write system call number to eax.
After we set up the evironment we simply call interupt 80 which performs context
switch to kernel and performs actions inplemented in kernel sys_write call.
Second syscall we use in this program requires even less set up - only syscall
number needs to be moved to eax register before calling the kernel.
To see all system calls available in your kernel have a look into
linux/arch/architecture/include/asm/unistd.h.
Linux kernel 2.6.32 contains about 360 syscalls for ARM architecture
and about 330 syscalls in x86 specific unistd_32.h
Here's how you build and run the program:
Notice that we don't use any high-level library API in doing this, only kernel syscalls.
If you change the length of the message to be greater then actual string length
you may be able to see something really interesting on screen ;-)
2. Our second example (based on fixed NASM distro) is a bit more interesting since we are going
to call assembly functions and variables available in libgeo.s from C application (testlib.c):
Here's the assembly code first:
There are two fuctions implemented in assembly language here (lrotate and printasm),
several pointers and integers and a formating string. Since we are going to use them
in C code they are declared as GLOBAL. Also we make use of libc printf function
which is declared as EXTERN. Some other things worth noticing here:
when we need to call function with parameters we push them on stack first,
in reverse order, then push formatting string and finally call function (printf).
Long strings could be split into several parts using db instruction and some
formatting like line feed (0xa or 10) ending with zero (null terminating).
C application (testlib.c) making use of our assembly code is quite straightforward:
#include <stdio.h> #include <stdlib.h> long lrotate(long, int); void printasm(void); // without [] - Segmentation fault // without array length (4) - warning char asmstr[8]; int textptr; int selfptr; int integer; int main(void) { printf("\nTesting lrotate: expect 0x00400000 and 0x00000001\n"); printf("lrotate(0x00040000, 4) = 0x%08lx\n", lrotate(0x40000, 4)); printf("lrotate(0x00040000, 14) = 0x%08lx\n\n", lrotate(0x40000, 14)); printf("Pointers from asm:\n"); printf("textptr = %p, selfptr = %p\n", textptr, selfptr); printf("&printasm() = %p\n\n", &printasm); printf("Long assembly string: %s", asmstr); printf("Printasm: "); printasm(); exit(0); }
We declare all assembly functions/variables first, notice that asmstring which is
multi-part string in assembly is declared as char array, if you delete brackets
program will crash because of "Segmentation fault", array length is needed
to avoid compile time warnings.
To build and run the program enter the following on command line:
3. Third program we describe here illustrates usage of command line parameters in assembly language
as well as some basic error checking. It prints first n numbers of famous Fibonacci sequence.
Here's the program:
First we declare external C functions we need (printf, atoi and exit),
second we read total number of command line parameters (including program name)
from esp register. If this number is not two (that is program name and an integer),
we go to badarg label and print error message which contains (wrong) number of parameters.
If input is ok, we print program name and parameter entered, convert string value
of parameter to int using atoi, initialize eax and ebx registers using xor, and start
Fibonacci sequence calculus using print loop printing each new member with printf.
When counter (ecx) becomes zero we call C exit function.
Here's how you can build the program:
Notice that this time we use Linux dynamic linker to produce elf executable.
This is required step if you want to keep your executable slim and load
all required libraries (libc in this case) dynamically at runtime.
Let's run the program (first with wrong number of parameters):
geo@fermat:/home/work/asm/nasm$ ./fibonacci 5 6 wrong number of args: 3 geo@fermat:/home/work/asm/nasm$ ./fibonacci 22 program ./fibonacci is running with arg 22: 1 1 2 3 5 8 13 21 34 55 89 144 233 377 610 987 1597 2584 4181 6765 10946 17711 geo@fermat:/home/work/asm/nasm$
So when we provide wrong number of parameters (2 instead of 1) our
error check is triggered and program exits after printing a message.
And if input is ok we get first n members of Fibonacci sequence
where each number is the sum of the previous two.
You can download source code and binaries of examples from here.
For this tutorial I used NASM 2.09 on Debian Squeeze.
Part 2 of NASM tutorial: NASM file operations with Linux system calls, debugging.