Linux Assembly Tutorial

Quickstart

Written by: Derick Swanepoel (derick@maple.up.ac.za)
Version 1.0 - 2002-04-19, 01:50am

Download as zipfile

JMP Step-by-Step Guide

Contents

1. Intro

2. Comparison of a Linux assembly program and a DOS assembly program

3. More About Linux System Calls

4. Command Line Arguments and Writing to a File

5. Compiling and Linking

1. Intro

This Quickstart aims to show you the ropes on Linux assembly as quickly as possible. Basically, it just points out the differences between a Linux and DOS assembly program with just enough explanation not to confuse you. For more detail and why things are the way they are, see the Step-by-Step Guide.

2. Comparison of a Linux assembly program and a DOS assembly program

SECTION .DATA
	hello:     db 'Hello world!',10
	helloLen:  equ $-hello

SECTION .TEXT
	GLOBAL _START

_START:



	; Write 'Hello world!' to the screen
	mov eax,4            ; 'write' system call
	mov ebx,1            ; file descriptor 1 = screen
	mov ecx,hello        ; string to write
	mov edx,helloLen     ; length of string to write
	int 80h              ; call the kernel

	; Terminate program
	mov eax,1            ; 'exit' system call
	mov ebx,0            ; exit with error code 0
	int 80h              ; call the kernel

DOSSEG
.MODEL LARGE
.STACK 200h

.DATA
	hello      db 'Hello world!',10,13,'$'
	helloLen   db 14

.CODE
	ASSUME CS:@CODE, DS:@DATA

START:
	mov ax,@data
	mov ds,ax

	; Write 'Hello world!' to the screen
	mov ah,09h            ; 'print' DOS service
	mov dx,offset hello   ; string to write
	int 21h               ; call DOS service



	; Terminate program
	mov ah,4Ch            ; 'exit' DOS service
	mov ax,0              ; exit with error code 0
	int 21h               ; call DOS service
END START

Lets compare each part in the two programs:

• The first three lines of the DOS program doesn't exist in the Linux program. Linux is a 32-bit protected mode operating system, and in 32-bit assembly there are no memory models. Also, all segment registers and paging have already been set up to give you the same 32-bit 4Gb address space, so you can ignore all segment registers. It is also not necessary to specify the stack size.
• Some differences between the Linux NASM structure and DOS TASM/MASM structure:
  • The data / code sections are defined by writing SECTION .DATA instead of just .DATA
  • Linux NASM allows us to declare constants with the EQU instruction, for example:
    bufferlen: equ 400
    So whenever it sees bufferlen in your program, it will substitute the value '400'. That means you don't have to put square brackets around bufferlen to get its actual value. (Note: this only works for constants. The values of all other variables are still obtained using [varname]).
  • Another neat NASM feature is the '$' token: when NASM sees an '$' it substitutes it with the assembly position at the beginning of that line. So what does this mean? This gives us an easy way to define the length of a string we've just declared. After declaring a variable containg a string

    	hello:     db 'Hello world!',10

    we can put on the next line

    	helloLen:  equ $-hello

    This will make helloLen equal to (position at beginning of line) - (position of hello). If you look at those two lines in the program, you can see this will give us the length of 'Hello world!',10, which is 13 (12 characters plus the linefeed character).
    If this doesn't make sense, don't worry, just know that this is an easy way to define the length of a string.
  • Strings you want to print out in Linux don't need to be $-terminated like in DOS. Instead, you supply the length of the string as one of the parameters. (This is much more flexible, because you can now print out only a part of the string, and your computer won't blow up when you forget the $ like in DOS.)
  • To print out a string with a newline at the end, you only need to need to add a linefeed character (10) to the end of the string in Linux. In DOS, you need both a linefeed and a carriage return (13).
  • The .CODE section is called .TEXT in Linux
  • Right at the beginning of the .TEXT section, there must be a declaration specifying the entry point of the program: GLOBAL _START
  • There is no ASSUME directive like in the DOS program, because we don't need to worry about segments.
  • The program's entry point is called whatever you declared it to be at the beginning of the .TEXT section (in our case it's _START). Also, the Linux program doesn't end with END _START like the DOS program.
• The first two lines after the START: label in the DOS program make sure that the DS register points to the data segment. Once again, Linux doesn't need this because the segments are taken care of for us.
• In 16-bit DOS assembly, we use the normal 16-bit registers AX, BX, CX, DX etc. In 32-bit Linux assembly we use the 32-bit extended registers EAX, EBX, ECX, EDX etc. (Note that there is no such thing as EAL. AX is the low 16 bits of EAX, while AH is the high 8 bits of AX and AL is the low 8 bits of AX.)
• In DOS, when we want the memory address of a variable to be put in a register, we must use offset to point to the offset of the variable in the correct segment (mov dx,offset hello). In Linux, we don't need offset because it's implied - we just write mov ecx,hello
• In DOS, we call int 21h to use a DOS service like printing out a string. In Linux, you use system calls, which are accessed by calling int 80h (the kernel interrupt). In DOS the function number (eg. 9 to print a string) always goes in AX; in Linux it always goes in EAX. As in the example, if we want to print out a string we use the "write" syscall, which is function number 4. We put '4' in EAX, the number of the file descriptor to write to in EBX (in this case '1', the screen), the location of the string to print in ECX (mov ecx,hello), and the length of the string in EDX (mov ecx,helloLen). Then we call the kernel interrupt (int 80h), and voila!
• To exit a Linux program, we use the exit syscall (function 1, so we write mov eax,1). We want to exit with an exit code of 0 (no error), so we put 0 in EBX. Then we call the kernel with int 80h again, and we're done.

3. More About Linux System Calls

There are six registers that are used for the arguments that a system call takes. The first argument goes in EBX, the second in ECX, then EDX, ESI, EDI, and finally EBP, if there are so many. If there are more than six arguments, EBX must contain the memory location where the list of arguments is stored.

All the syscalls are listed in /usr/include/asm/unistd.h, together with their numbers. However, for your convenience you can simply find them in this Linux System Call Table, together with some other useful information (eg. what arguments they take). The syscalls are fully documented in section 2 of the manual pages, so you can just go man 2 write to find out what the write syscall does, what arguments it takes, etc.

4. Command Line Arguments and Writing to a File

section .data
	hello     db	'Hello, world!',10	; Our dear string
	helloLen  equ	$ - hello		; Length of our dear string

section	.text
    global _start

_start:
	pop	ebx		; argc (argument count)
	pop	ebx		; argv[0] (argument 0, the program name)
	pop	ebx		; The first real arg, a filename

	mov	eax,8		; The syscall number for creat() (we already have the filename in ebx)
	mov	ecx,00644Q	; Read/write permissions in octal (rw_rw_rw_)
	int	80h		; Call the kernel
				; Now we have a file descriptor in eax

	test	eax,eax		; Lets make sure the file descriptor is valid
	js	skipWrite	; If the file descriptor has the sign flag
				;  (which means it's less than 0) there was an oops,
				;  so skip the writing. Otherwise call the filewrite "procedure"
	call	fileWrite

skipWrite:
	mov	ebx,eax		; If there was an error, save the errno in ebx
	mov	eax,1		; Put the exit syscall number in eax
	int	80h		; Bail out

; proc fileWrite - write a string to a file
fileWrite:
	mov	ebx,eax		; sys_creat returned file descriptor into eax, now move into ebx
	mov	eax,4		; sys_write
				; ebx is already set up
	mov	ecx,hello	; We are putting the ADDRESS of hello in ecx
	mov	edx,helloLen	; This is the VALUE of helloLen because it's a constant (defined with equ)
	int	80h

	mov	eax,6		; sys_close (ebx already contains file descriptor)
	int	80h
	ret
; endp fileWrite

DOSSEG
.MODEL LARGE
.STACK 200h

.DATA
filename	db 14 dup (0)
filehandle	dw
hello		db 'Hello World!',10,13,'$'
helloLen	db 12

.CODE
ASSUME CS:@CODE, DS:@DATA

START:
	mov	AX,@DATA
	mov	ES,AX                  ; Point ES to the data segment for now

	mov	ah,62h
	int	21h                    ; Get the PSP
	mov	ds,bx
	mov	bx,81h                 ; Starting at the first printable character
	add	bl, byte ptr [ds:80h]  ; Get address of last character
	mov	cl, byte ptr [ds:80h]  ; Also put it in CL
	inc	cl
	mov	[ds:bx], word ptr 0    ; Null terminate the argument

	mov	si,81h
	mov	di,0                   ; Copy the first argument into the data segment
	rep	movsb                  ;  into the filename variable

	mov	AX,@DATA
	mov	DS,AX                  ; Point DS to the data segment, like normal

	call	fileCreate
	call	fileWrite
	call	fileClose

	mov	AX,4C00h
	int	21h                    ; Bye-bye!
END START

proc fileCreate
	mov	ah,3Ch                 ; Creat DOS service (yes, it is called 'creat')
	mov	cx,0                   ; File attributes
	mov	dx,offset filename     ; Put ADDRESS of filename in DX
	int	21h

	mov	[filehandle],ax        ; File handle is returned in AX, put in a variable
	ret
endp fileCreate

proc fileClose
	mov	ah,3Eh
	mov	bx,[filehandle]
	int	21h
	ret
endp fileClose

proc fileWrite
	mov	ah, 40h
	mov	bx, [filehandle]
	mov	dx, offset hello       ; ADDRESS of string to be written
	xor	cx, cx                 ; If I don't do this, things blow up in my face
	mov	cl, [helloLen]         ; VALUE of length of string to be written
	int	21h
	ret
endp fileWrite

As you can see, the Linux program is much simpler than the DOS one (40 lines in Linux, with liberal commenting, vs. 66 for DOS). Everything makes sense in the Linux program, whereas a lot of the stuff in the DOS one still makes me go "Huh?" Lets check out the differences:

1. Firstly, getting the command line arguments of the Linux program is way easier than the DOS one. All the arguments are sitting on the stack when the program starts, so all we need to do is pop them off. The first value popped off is the number of arguments (called argc in C/C++), the second is the name of the program, and finally we get the actual command line arguments. Coolest of all, when we pop the command line argument off the stack, it actually puts the address of that string in EBX, so once again no segment/offset missions.
   This just took us an entire 3 instructions - compared to the 14 insane ones for the DOS program! No messing around with PSPs and stuff - simple, isn't it?
2. NB: NASM doesn't have procedures like you may have used in TASM. That's because procedures don't really exist in assembly: everything is a label. So if you want to write a "procedure" in NASM, you don't use proc and endp, but instead just put a label (eg. filewrite:) at the beginning of the "procedure's" code. If you want to, you can put comments at the start and end of the code just to make it look a bit more like a procedure (like I did in the example).
3. NB²: When you jump to a label with JMP or any of the jump instructions, you don't RET from it. Never! If you're lucky it won't explode on you, but it's definitely not right. The only time you RET is when you've called the "procedure" with CALL. Otherwise you're just going to have to jump around like a kangaroo weaving a spaghetti code masterpiece. (Note that this is applicable to any assembly, not just Linux or NASM).
4. Next we create the file: notice the file permissions in Linux (you can find out more about them by reading the creat syscall's manpage – yes, it is spelled "creat"). Since we want to be smart with Linux, why not also include some error checking while we're at it? We can easily check if the creat syscall failed by checking the value it returned: if it's less than 0 then something broke, so skip the writing part and exit with the error code.
5. Now we write 'Hello world!' to the file using the file descriptor (called file handle in DOS) returned by the creat syscall. Then we close it, and exit.

5. Compiling and Linking

To compile a program with NASM:

nasm -f elf program.asm

ld -s -o program program.o

Appendix A. References

Writing a useful program with NASM
The NASM documentation
Introduction to UNIX assembly programming
Linux Assembler Tutorial by Robin Miyagi
Section 2 of the manpages

Linux Assembly Tutorial

Step-by-Step Guide

Written by: Derick Swanepoel (derick@maple.up.ac.za)
Version 1.0 - 2002-04-19, 01:50am

Download as zipfile

JMP Quickstart

Contents

1. Introduction

2. Why this Tutorial?

3. The Netwide Assembler (NASM)

3.1 A Note on Assemblers

3.2 Where do I get NASM?

4. Introduction to Linux Assembly

4.1 Main Differences Between DOS and Linux Assembly

4.2 The Parts of an Assembly Program

4.3 Linux System Calls

4.3.1 Reading the Manpages

4.4 "Hello World!" in Linux Assembly

4.5 Compiling and Linking

5. More Advanced Concepts

5.1 Command Line Arguments and the Stack

5.2 "Procedures" and Jumping

6. Conclusion

Appendix A. The terminal is your friend - how to use it

Appendix B. Installing NASM (and other stuff) on Linux

Appendix C. References

1. Introduction

This tutorial is an introduction to coding assembly in Linux. There are two "versions" to accommodate various people:

• The Step-by-Step Guide: This version explains everything in detail. It assumes that you have done at least a little bit of DOS assembly, and that you have Linux on your computer (although you may not have used it much yet). Since not everyone may know how to use Linux, there are links to sections where I explain how to do basic things like use the terminal and the DOS-equivalent commands.
• The Quickstart: If you're in a hurry and just want to see a Linux assembly program, compile it and run it, this is for you. It assumes that you understand basic DOS assembly, and that you know how to use the terminal. Basically, it just points out the differences between a Linux and DOS assembly program with just enough explanation not to confuse you.

2. Why this Tutorial?

Mainly, the reason for this tutorial is to make assembly programming easier, better and more practical by doing it in Linux instead of DOS. Also, it may teach you a bit of Linux while you're at it (unless you're already at home with it).

Programming in assembly may seem quite masochistic (and writing entire programs in it simply ridiculous), especially in these days of super-optimizing compilers and visual development tools that do just about everything for you. However, there is an advantage in understanding more about the inner workings of your processor and kernel, and assembly is a good way of learning this. Sometimes assembly can be extremely useful for sticking inline in a C/C++ program. And if your program really has a "need for speed", you can tweak and optimize the assembly generated by the compiler (of course, you need to be pretty elite to produce better code than today's compilers.)

Since there was this notion that we were to be taught how to use Linux during COS284 (sort of as an aside), the idea was that we would code assembly in Linux. But not Linux assembly - DOS assembly, in a DOS emulator, with a DOS text editor. Of course, this entirely defeats the purpose, but maybe it was to be done this way mainly because there aren't so many Linux assembly tutorials and sample code as for DOS. Well, here is a tutorial that'll teach you the basics of Linux assembly.

3. The Netwide Assembler (NASM)

3.1 A Note on Assemblers

Linux will almost always be intalled with the default assemblers as and as86 available, and quite likely also gas. However, we will be using NASM, the Netwide Assembler. It uses the Intel syntax just like TASM, MASM, and other DOS assemblers, and the structure is also fairly similar. (Useless info: as and gas use the AT&T syntax, which is somewhat different – eg. all registers must be prefixed with a %, and the source operand comes before the destination. See the References for a link to a tut using as and AT&T syntax.)

NASM is cool because it's portable (there are Linux, Unix and DOS versions), it's free and it's powerful with lots of nice features. Trust me.

3.2 Where do I get NASM?

If you selected "Development Tools" when you installed Linux, chances are you already have NASM. It comes standard with most Linux distributions, so you don't need to download it. To check if you've got it, just ask Linux, "Where is NASM?" Here's how:

1. Open a terminal. (For some basic Linux terminal skills, go to The terminal is your friend - how to use it)
2. Type whereis nasm and press ENTER.

If you see a line that says something like nasm: /usr/bin/nasm then you're fine. If all you see is nasm: then you need to install NASM. Here are some instructions on how to install NASM (or anything else) on Linux.

If you feel like getting the latest and greatest version of NASM, visit their website www.cryogen.com/Nasm, or get it with FTP from our local Linux mirror ftp.kernel.za.org/pub/software/devel/nasm/binaries.

4. Introduction to Linux Assembly

4.1 Main Differences Between DOS and Linux Assembly

• In DOS assembly, most things get done with the DOS services interrupt int 21h, and the BIOS service interrupts like int 10h and int 16h. In Linux, all these functions are handled by the kernel. Everything gets done with "kernel system calls", and you call the kernel with int 80h. One of the wonderful things about Linux system calls are that there are fewer of them (about 190) than DOS, but they are far more practical (you don't have obsolete crap like functions that load casette BASIC and things left over from DOS 1.0). Linux system calls create files, handle processes and other such useful stuff - no strings attached (mmm, bad pun ;-)
• Linux is a true, 32-bit protected mode operating system, so this enables us to do real, up-to-date 32-bit assembly. This 32-bit code runs in the flat memory model, which basically means you don't have to worry about segments at all. This makes life a lot easier, because you never need to use a segment override or modify any segment register, and every address is 32 bits long and contains only an offset part. (If this is just a lot of waffling to you, don't worry, just know that it's good and will simplify things for you.)
• In 32-bit assembly, you use the extended 32-bit registers EAX, EBX, ECX and so on instead of the normal 16-bit registers AX, BX, CX etc.
• DOS is dead. It's 16-bit. It's obsolete. The only people that still write DOS assembly are crazy old hackers that are too attached to their 386s to throw them away. Linux assembly has practical applications (parts of the OS are written in assembler, hardware drivers are often coded in assembler).

4.2 The Parts of an Assembly Program

An assembly program can be divided into three sections:

• The .data section
  
  This section is for "declaring initialized data", in other words defining "variables" that already contain stuff. However this data does not change at runtime so they're not really variables. The .data section is used for things like filenames and buffer sizes, and you can also define constants using the EQU instruction. Here you can use the DB, DW, DD, DQ and DT instructions. For example:

  section .data
  	message:    db 'Hello world!'     ; Declare message to contain the bytes 'Hello world!' (without quotes)
  	msglength:  equ 12                ; Declare msglength to have the constant value 12
  	buffersize: dw 1024               ; Declare buffersize to be a word containing 1024
  

• The .bss section
  
  This section is where you declare your variables. You use the RESB, RESW, RESD, RESQ and REST instructions to reserve uninitialized space in memory for your variables, like this:

  section .bss
  	filename:   resb    255           ; Reserve 255 bytes
  	number:     resb    1             ; Reserve 1 byte
  	bignum:     resw    1             ; Reserve 1 word (1 word = 2 bytes)
  	realarray:  resq    10            ; Reserve an array of 10 reals
  

• The .text section
  
  This is where the actual assembly code is written. The .text section must begin with the declaration global _start, which just tells the kernel where the program execution begins. (It's like the main function in C or Java, only it's not a function, just a starting point.) Eg.:

  section .text
  	global _start
  
  _start:
  	pop    ebx        ; Here is the where the program actually begins
  	.
  	.
  	.
  

4.3 Linux System Calls

Linux system calls are called in exactly the same way as DOS system calls:

1. You put the system call number in EAX (we're dealing with 32-bit registers here, remember)
2. You set up the arguments to the system call in EBX, ECX, etc.
3. You call the relevant interrupt (for DOS, 21h; for Linux, 80h)
4. The result is usually returned in EAX

Some example code always helps:

	mov	eax,1       ; The exit syscall number
	mov	ebx,0       ; Have an exit code of 0
	int	80h         ; Interrupt 80h, the thing that pokes the kernel and says, "Yo, do this"

But how do you find out what these system calls are, and what they do, and what arguments they take? Firstly, all the syscalls are listed in /usr/include/asm/unistd.h, together with their numbers (the value to put in EAX before you call int 80h). However, for your convenience you can simply find them in this Linux System Call Table, together with some other useful information (eg. what arguments they take). Take a look at the list of syscalls – there are things like sys_write (4), sys_nice (34) and of course sys_exit (1). To find out just what these things do, you can look them up in the Linux manual pages (commonly called "the manpages"). That is what the next section is about.

4.3.1 Reading the Manpages

First, open a terminal (or switch to one of the 6 consoles with CTRL+ALT+F1 through F6 - to get back to graphical mode press CTRL+ALT+F7). Say now you want to know what the "write" syscall does. Type man 2 write and press ENTER. This will bring up the manual page on "write" from section 2 of the manpages.

Under the NAME section is the syscall's name and what it does – in this case:

write - write to a file descriptor

Next, under the SYNOPSIS section you see a fairly ugly line:

ssize_t write(int fd, const void *buf, size_t count);

Now we can finally write our first Linux assembly program!

4.4 "Hello World!" in Linux Assembly

Of course, the appropriate way to begin would be to print out "Hello world!" To print to the screen, we write to the special file called STDOUT (standard output), which is file descriptor 1. Here is the program in full:

section .data
	hello:     db 'Hello world!',10    ; 'Hello world!' plus a linefeed character
	helloLen:  equ $-hello             ; Length of the 'Hello world!' string
	                                   ; (I'll explain soon)

section .text
	global _start

_start:
	mov eax,4            ; The system call for write (sys_write)
	mov ebx,1            ; File descriptor 1 - standard output
	mov ecx,hello        ; Put the offset of hello in ecx
	mov edx,helloLen     ; helloLen is a constant, so we don't need to say
	                     ;  mov edx,[helloLen] to get it's actual value
	int 80h              ; Call the kernel

	mov eax,1            ; The system call for exit (sys_exit)
	mov ebx,0            ; Exit with return code of 0 (no error)
	int 80h

Copy this program into a text editor of your choice (I use vi or SciTE), and save it as hello.asm in your home directory (/home/yourname).

4.5 Compiling and Linking

1. If you don't have a terminal or console open, open one now.
2. Make sure you are in the same directory as where you saved hello.asm.
3. To assemble the program, type
   nasm -f elf hello.asm
   If there are any errors, NASM will tell you on what line you did what wrong.
4. Now type ld -s -o hello hello.o
   This will link the object file NASM produced into an executable file.
5. Run your program by typing ./hello
   (To run programs/scripts in the current directory, you must always type ./ before the name, unless the current directory is in the path.)

5. More Advanced Concepts

Before I go on, you're probably wondering what that equ $-hello thing is doing in our Hello World program (line 3). As you may remember, when you use equ to declare a variable (instead of db, for example), you are actually declaring a constant. Declaring the length of our string as a constant is sensible because it sure isn't going to change. But how does $-hello turn out to be the length of 'Hello world!' ? When NASM sees a '$' it replaces it with the assembly position at the beginning of that line. (That is also the position at the end of the previous line.) So subtracting the position of a variable from '$' will give us the number of bytes between the variable and '$'. If we want to declare a variable that contains the length of a string we've declared by saying hello: db 'Hello world!',10 then we just stick helloLen: equ $-hello on the next line. That will make helloLen equal to the number of bytes that hello takes up in memory, which in this case is 13 (the linefeed character also counts). Don't worry if this confuses you – just remember that it's a neat and easy way to declare the length of a string.

If you're more than just casually interested, I'd encourage you to check out the NASM documentation for more information on these things, and how to use some of the other neat features that I'm not going to mention in this tutorial.

5.1 Command Line Arguments and the Stack

Getting the command line arguments from a DOS program is not an enjoyable experience, because working with the PSP and having to worry about segments is simply a pain. In Linux things are much simpler: all arguments are available on the stack when the program starts, so to get them you just pop them off.

As an example, say you run a program called program and give it three arguments:

./program foo bar 42

Now lets write the program program that takes the three arguments:

section .text
	global _start

_start:
	pop	eax		; Get the number of arguments
	pop	ebx		; Get the program name
	pop	ebx		; Get the first actual argument ("foo")
	pop	ecx		; "bar"
	pop	edx		; "42"

	mov	eax,1
	mov	ebx,0
	int	80h		; Exit

5.2 "Procedures" and Jumping

NB: NASM doesn't have procedure definitions like you may have used in TASM. That's because procedures don't really exist in assembly: everything is a label. So if you want to write a "procedure" in NASM, you don't use proc and endp, but instead just put a label (eg. fileWrite:) at the beginning of the "procedure's" code. If you want to, you can put comments at the start and end of the code just to make it look a bit more like a procedure. Here's an example in both Linux and DOS:

Linux	DOS
; proc fileWrite - write a string to a file fileWrite: mov eax,4 ; write system call mov ebx,[filedesc] ; File descriptor mov ecx,stuffToWrite mov edx,[stuffLen] int 80h ret ; endp fileWrite	proc fileWrite mov ah,40h ; write DOS service mov bx,[filehandle] ; File handle mov cl,[stuffLen] mov dx,offset stuffToWrite int 21h ret endp fileWrite

NB²: I assume that you're familiar with labels and jumping to them with instructions like JMP, JE or JGE. Now that you've seen that "procedures" are actually labels, there is one very important thing to remember: If you are planning to return from a procedure (with the RET instruction), don't jump to it! As in "never!" Doing that will cause a segmentation fault on Linux (which is OK – all your program does is terminate), but in DOS it may blow up in your face with various degrees of terribleness. The rule to remember is:

You may jump to labels, but you must call a procedure.

Calling a procedure is of course done with the CALL instruction. This makes life a bit difficult when you want to do things like "if-then-else". If you have a situation such as "if this happens, call procedure 1, else call procedure 2" there's only one thing to do: Jump around like a kangaroo weaving a spaghetti code masterpiece. Lets look at an example. First, here is some normal, sane code:

	if (AX == 'w') {
	   writeFile();
	} else {
	   doSomethingElse();
	}

	cmp	AX,'w'		; Does AX contain 'w'?
	jne	skipWrite	; If not, skip writing by jumping to another label, and doSomethingElse there...
	call	writeFile	; ...else call the writeFile procedure...
	jmp	outOfThisMess	; ...and jump past all of this spaghetti

skipWrite:
	call	doSomethingElse
outOfThisMess:
	...			; The rest of the program goes on here

5.3 A Program with Everything

Now we can finally take a look at a program that does something remotely useful, containing almost everything we've covered. In the Quickstart version of this tutorial, I have included a Linux and a DOS version of the program we wrote in Practical 3 (the one that writes 'Hello world!' to the file given as a command line argument). Check it out and see how much simpler and logical the Linux program is compared to the DOS one.

6. Conclusion

Well, that's about it for this tutorial. I hope this has been a suitable introduction to doing assembly programming in Linux. If you have any questions, suggestions or problems, feel free to e-mail me at derick@maple.up.ac.za. This is my first tutorial and I'm no assembly hacker either, so I welcome your comments.

Good luck and happy coding!

Appendix A. The terminal is your friend - how to use it

The terminal / console is an integral and very useful part of Linux. Linux has an excellent set of command line utilities and programs, and you can control the whole system without a GUI. Sometimes this is actually easier and faster. For programming in assembly you are obviously going to have to work in the terminal, and this part will show you how.

Before you start, keep in mind that Unix/Linux is case sensitive, so "Blah" is not the same as "blah" or "blaH".

• Opening a terminal: If you're in KDE or Gnome, simply click on the terminal icon or browse the "Start"-menu for a terminal program. Alternatively you can switch to one of the 6 text-mode consoles by pressing CTRL+ALT+F1 through F6. To get back to graphics mode press CTRL+ALT+F7. When you open a terminal or log in on a console, you are plonked into your home directory, which is called whatever your username is. You are presented with a prompt that looks something like this:

  [delta@quantumcow asmtut]$
  

  The part before the '@' tells you your username (mine is delta), then the computer name (quantumcow), and then the top-level current directory (asmtut).
• Finding out where you are: At the prompt, type pwd. This will show you the "present working directory", in other words where you are now. For example:

  [delta@quantumcow asmtut]$ pwd
  /home/delta/asmtut
  

• Changing directories: To change to another directory you use the cd command. Note that it works a bit different than the DOS cd. Firstly, there must be a space between "cd" and the directory name. Secondly, in Unix/Linux, the directory separator is a forward slash (/) not a backslash (\). To change to the parent directory of the current one, you go cd ... To go up two levels in the directory tree, type cd ../... Here are some examples – try them out:

  [delta@quantumcow asmtut]$ cd /usr/share/doc
  [delta@quantumcow doc]$ pwd
  /usr/share/doc
  [delta@quantumcow doc]$ cd ..
  [delta@quantumcow share]$ cd ../..
  [delta@quantumcow /]$
  

  At the end of this example, you end up in the root directory, / (similar to C:\). Now to get back to your home directory, type cd ~
  The tilde (~) is a shortcut for your home directory.
• Finding out what's in a directory: To list the current directory's contents, type ls. If you're in your home directory and haven't used Linux much, there probably won't be many files. Change to a directory like /etc and list its contents – lots of files! (The /etc directory is where most of the system's configuration files are stored.) To get some more info, you can do a "long list" by typing ls -l or simply ll. In my home directory it looks like this:
  
  Directories are highlighted in blue, executable files in green, compressed archives in red and images in purple.
• Finding out what's in a file: You can use either cat or less to view the contents of a file. Use less when you know the output will be more than one screen long, because less will pause at every screen of text, and allows you to scroll up and down.

  [delta@quantumcow asmtut]$ cat foo.txt
  Hello, world!
  

• The wonders of tab-completion: Linux has a wonderful feature called tab-completion. Almost anywhere, when you are typing in the name of a file or directory, you can press the TAB key and Linux will complete the name for you. This is especially useful when you're dealing with things that have long names. Try find a directory with really long directory names in it, and then cd to one of them using tab-completion. For example, type cd /usr/share/doc/cons and press TAB. Tada! Linux has completed the name for you, (console-tools-19990829/) and you can just press ENTER.
  
  If you try typing cd /usr/share/doc/proc and then press TAB you'll hear a beep. That's because there are more than one directory in /usr/share/doc that starts with "proc", so Linux doesn't know which one you want. If you press TAB again it will display the directories starting with "proc". Now you can type some more letters of the directory you want (just enough to identify it uniquely will do), and press TAB again. Neat, isn't it?

Appendix B. Installing NASM (and other stuff) on Linux

In order to install programs on your Linux system, you must be root (administrator). You can decide whether you want to do this with the GUI utilities or in a terminal – I recommend you try both, for the added experience ;)

Using KDE / Gnome

If you're working in KDE / Gnome, installing things is fairly straightforward:

1. If you are logged in as a normal user, log out and log in as root.
2. Pop your Linux CD in your CD-ROM drive, and it should be automounted (NASM is on the 2^nd CD). You can then use a file manager (Konqueror, Nautilus) to go to /mnt/cdrom where you should see the contents of the Linux CD. If there's nothing, go to the desktop, right-click on the CD-ROM icon and click "Mount".
3. In /mnt/cdrom, go to RedHat, then RPMS. You should see a lot of files with the extension .RPM – look for nasm-0.98-8.i386.rpm.
4. Click/double-click on it to open it with the package manager. From there it shouldn't be too much of a mission to install. Also install nasm-doc-0.98-8.i386.rpm, the documentation for NASM.

Using the Terminal

Installing stuff by means of a terminal isn't difficult either:

1. If you weren't logged in as root, become root in the terminal by typing su (for "substitute user"). After entering your password, you will now be logged in on that terminal as root.
2. Mount the CD-ROM by typing mount /dev/cdrom
3. Change to the packages directory: cd /mnt/cdrom/RedHat/RPMS
4. Install NASM with the RedHat Package Manager, by typing: rpm -i nasm-0.98-8.i386.rpm
   (Hint: use tab-completion!)
   Also install nasm-doc-0.98-8.i386.rpm, the documentation for NASM.
5. If you su'd to become root, type exit to log out and stop being root.

Appendix C. References

Writing a useful program with NASM
The NASM documentation
Introduction to UNIX assembly programming
Linux Assembler Tutorial by Robin Miyagi
Section 2 of the manpages

(source)

Linux System Call Table

The following table lists the system calls for the Linux 2.2 kernel. It could also be thought of as an API for the interface between user space and kernel space. My motivation for making this table was to make programming in assembly language easier when using only system calls and not the C library (for more information on this topic, go to http://www.linuxassembly.org). On the left are the numbers of the system calls. This number will be put in register %eax. On the right of the table are the types of values to be put into the remaining registers before calling the software interrupt 'int 0x80'. After each syscall, an integer is returned in %eax.

For convenience, the kernel source file where each system call is located is linked to in the column labelled "Source". In order to use the hyperlinks, you must first copy this page to your own machine because the links take you directly to the source code on your system. You must have the kernel source installed (or linked from) under '/usr/src/linux' for this to work.

Note for sys_ipc (117): this syscall takes six arguments, so it can't fit into the five registers %ebx - %edi; the last parameter (not shown) is of type 'long'. This syscall requires a special call method where a pointer is put in %ebx which points to an array containing the six arguments.

I will now explain exactly where in the kernel source that I got the information in the table above. I do this because 1) changes in the source are bound to happen, 2) you might be curious, or 3) I might've made an error.

System Call Numbers

For the numbers of the syscalls, look in arch/i386/kernel/entry.S for sys_call_table. The syscall numbers are offsets into that table. Several spots in the table are occupied by the syscall sys_ni_syscall. This is a placeholder that either replaces an obsolete syscall or reserves a spot for future syscalls.

Incidentally, the system calls are called from the function system_call in the same file; in particular, they are called with the assembly instruction 'call *SYMBOL_NAME(sys_call_table)(,%eax,4)'. The part '*SYMBOL_NAME(sys_call_table)' just gets replaced by a symbol name in sys_call_table. SYMBOL_NAME is a macro defined in include/linux/linkage.h, and it just replaces itself with its argument.

Typedefs

Here are the typedef declarations in the prototypes above:

Struct Declarations

Here are the struct declarations for the table at the top: