ASSEMBLY LANGUAGE PROGRAMMING IN NASM

Why assembly?
-

Assembly is widely used in industry:

-

Embedded systems. Real time systems. Low level and direct access to hardware

Our First NASM Program

Running Our Code in NASM

To assemble a file, you issue a command of the form > nasm -f <format> <filename> Example: > nasm -f elf hello.asm It would create hello.o file that has elf format (executable and linkable format). To crreate an executable file hello from hello.o > gcc hello.o -o hello In order to run it you should write its name on the command line: > ./hello Which shows you the output of the program: > Hello world!

Basic Data Types

7 0 byte

15

87

0 word

31 high word

16 15 low word

0 doubleword

63 high doubleword

32 31 low doubleword

0 quadword

The Parts of an Assembly Program

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 instructions. For example:
section .data message: db 'Hello world!' ; Declare message to contain the bytes 'Hello world!' (without quotes)

msglength: equ 12
buffersize: dw 1024

; Declare msglength to have the constant value 12

; Declare buffersize to be a word containing 1024

The Parts of an Assembly Program

The .bss section This section is where you declare uninitialized variables. You use the RESB, RESW, RESD, RESQ instructions to reserve uninitialized space in memory for your variables, like this:
section .bss filename: resb 255 number: bignum: resb 1 resw 1 ; Reserve 255 bytes ; Reserve 1 byte ; Reserve 1 word (1 word = 2 bytes) ; Reserve an array of 10 quads

realarray: resq 10

The Parts of an Assembly Program

The .text section This is where the actual assembly code is written. The .text section must begin with the declaration of a global symbol, like global main, 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 main

main:
mov eax, 4 ; Here is the where the program actually begins . .

CPU Registers (32 bit)

31 0

eax ebx
ecx edx esi edi esp ebp

Accumulator register Base register Counter register

Data register
source index register destination index register stack pointer register base pointer register

CPU Registers (16 bit)

eax ebx ecx edx esi edi 31 16 15 ax bx cx 0

The least significant 16-bits of these registers have an additional register name that can be used for accessing just those 16-bits. Note: There are no register names for the most significant 16-bits

dx si
di

esp ebp

sp bp

CPU Registers (8 bit)

31 eax ebx ecx edx 16 15 0 15 ah bh ch dh 87 al bl cl dl 0

ax
bx cx

dx

The 2 least significant bytes of registers eax, ebx, ecx and edx also have register names, that can be used for accessing those bytes. Note: There are no register names for accessing the 2 least significant bytes of esi, edi, esp, ebp.

Basic Assembly Instructions

Each NASM standard source line contains a combination of the 4 fields: label: (pseudo) instruction operands ; comment

optional fields

Either required or forbidden by an instruction

Notes: 1. backslash (\) uses as the line continuation character: if a line ends with
backslash, the next line is considered to be a part of the backslash-ended line.

2. no restrictions on white space within a line. 3. a colon after a label is optional.

Examples:
1. mov ax, 2 ; moves constant 2 to the register ax 2. buffer: resb 64 ; reserves 64 bytes

Instruction arguments
A typical instruction has 2 operands.
The left operand is the target operand, while the right operand is the source operand 3 kinds of operands exists: 1. 2. 3. Immediate, i.e. a value Register, such as AX,EBP,DL Memory location; a variable or a pointer. mov eax, 5 mov eax, ebx mov eax, [var]

One should notice that the x86 processor does not allow both operands be memory locations.

mov [var1],[var2]

Calling C functions from NASM

Calling C functions from NASM

Looping in NASM

Looping in NASM

Macros in NASM

Macros in NASM

Including another file in NASM

Including another file in NASM

Including another file in NASM