A brief introduction to Assembly

Speed has always been the top priority amongst programmers. Who can build the fastest program that does this and this?! Assembly was once THE programming language to use when it came to speed. Hand optimized assembly code is almost always faster than compiler generated code from a higher programming language like C. Today, the compilers are more cleaver than ever before. Computers are also faster, so the faster developing times are far more prioritized than a very little speed increase in the executing time.

'What exactly is assembly?', you might ask. It's a very mashine dependent low level programming language. To illustrate the difference between a single line in C and assembly, I'll take a variable increase as an example. In C, you would write 'i++' and it would increase the value of your variable i. This cannot be done in a single line in assembly code (at least not on a x86). The 'i++' compiles into three lines of assembly:

mov eax, [i]
add eax, 1
mov [i], eax

What it does, is that it copies the value at the memory position i into the register EAX. Then it adds 1 to EAX and copies the increased value back into the memory position. Most of the assembly instructions are three characters long. Some common instructions are:

Instrucion Short description

mov dst,src Copies the value of src into dst

add dst,src dst = dst + src

sub dst,src dst = dst - src

mul dst,src dst = dst * src

div dst,src dst = dst / src

call address jumps to a memory address, uses 'ret' to return

jmp address as above, but without the return capability

jz address Conditional jump. Jumps only if the Zero-flag has been set
cmp a,b Compares a and b. Sets Zero-flag if they are different

push a Saves 'a' on the stack (pile of data, LIFO - Last in, first out)

pop dst Saves the top value on the stack in 'dst' and moves the stack pointer

int a Calls an interrupt (small program at BIOS or OS-level)

The decimal number system is based on 10. A number can be written 'A10^0 + B10^1 + ... + n10^n'. Example: 123* can be written '310^0 + 210^1 + 110^1'. The base is 10. In binary, the base is 2, so 123 would be written '12^0 + 12^1 + 02^2 + 12^3 + 12^4 + 12^5 + 12^6'. A little longer, but it still represents the same number. A commonly used system amongst programmers is hexadecimal which uses a base of 16. 'What comes after 9?', you ask. After 9 comes A, after that comes B, and so, until F (F = 15). The number 16 is written as 10 in hex. 123 would be represented as 'B16^0 + 716^1'.

So, when I write 10, no one accually knows if I mean hex, decimal or binary... Normally I would mean decimal, but to be certain, an additional character is set to the right of the number. If I write 10h, then I mean hex. Then same applies to binary. 1111011b = 7Bh = 123. An additional style of writing hex can also be used, especially when dealing with memory addresses. Put '0x' in front of the number: 7Bh = 0x7B. An additional '0' is sometimes added if the 'h'-style is used: 7Bh = 07Bh.

A Byte is a collection of 8 bits. The bits are refered to as bits 0-7. Bit 0 is called the LSB, the Least Significant Bit and is the least 'valuable'. Bit 7 is the MST, the Most Significant Bit.

A Word is two bytes i.e., that is 16 bits.

A Double Word is as the word indicates, two words, four bytes or 32 bits.

To specify a variable in Nasm, which I use, you can choose either a byte, a word, a double word (can be float), a 64-bit float or an 80-bit float (why 80-bits, I have no idea?). Look at this example:

my_byte db 0

my_word dw 0

my_double_word dd 0

my_double_float dq 0.0

my_ten_byte dt 0.0

To use a variable in Nasm, just use the mov instruction as described in the example at the top of the page.

That was about it... Hope it helped you understand my tutorials a little better =). If you want a more detailed assembly tutorial, read the Art of Assembly. It has pretty much everything you'll need to know to get started. Maybe even better explained than here...

Move on to tutorial 1