Assembly

This is a quick assembly tutorial teaches you the basic instructions and writing simple programs using assembly. All the programs in this tutorial is writting in Visual C++ 2008 Express Edition, using Irvine32.lib. You can get the Irvine32.lib in kipirvine's website click here. All the installation instruction can be found on kipirvine's website.

Lets learn a few basic things first before we start programming.

use semi-colon when you want to write a single comment.

; This is a single line comment

To write multiple lines comment, we will have to do this

comment *

This is a multiple lines comment section

comment /

This is a multiple lines comment section

Note: we can replace the aterisk with anything. As long as we end with the same thing of what we start with.

In assembly, we will work with Registers. The general purpose of registers are primiarily used for arithmetic and data movement. Each register can be addressed as either a single 32-bit value or a 16-bit value. Here is a list of the most common 32-bit and 16-bit registers.

32-bit	16-bit
EAX	AX
EBX	BX
ECX	CX
EDX	DX
ESI	SI
EDI	DI
ESP	SP

EAX is used by multiplication and division instructions. It is often called the extended accumulator register. Also, when we read input from the user, the data is stored into EAX.

ECX is used for loop counter. Whenever we do loops we will use the ECX register.

ESP addresses data on the statck. Mainly used for stack pointer.

ESI and EDI are used for memory transfer instructions. It's used for array indexing.

EDX is OFFSET register. Often used whenever we want to write something to the console.

Here is a list of integer storage sizes

byte 8

word 16

dword 32

qword 64

It is probably very confusing right now, but just keep in mind of all the registers and the storage sizes. Now lets see the most famous example in programming the "Hello World Program."

Click Here To Download Example

In this example, we move the offset of variable into edx, the values are store into edx. Then we call writstring and writestring will write anything that is store into the edx into the cmd.

Lets see another example

comment / Description: This is a basic program which writes multiple lines into the cmd / TITLE Multiplelines (MultipleLines.asm) INCLUDE Irvine32.inc ;This is where we declare all the data information .data ;Assign a 32-bit storage size to the variables variable1 BYTE "Hello! this is the 1st line", 0 variable2 BYTE "Hello! this is the 2nd line", 0 variable3 BYTE "Hello! this is the 3rd line", 0 ;This is the main procedure of the program .code main PROC ;Create a cmd console call clrscr ;Move the values in the variable1 into edx mov edx, OFFSET variable1 ;Write the value of variable1 into the console call writestring ;Skip line call crlf ;Move the values in the variable2 into edx mov edx, OFFSET variable2 ;Write the value of variable2 into the console call writestring ;skip line call crlf ;Move the values in the variable3 into edx mov edx, OFFSET variable3 ;Write the value of variable3 into the console call writestring ;skip line call crlf exit main endp END main

Click Here To Download Example

Now, what if you want to get input from users. Well! lets see a simple example on how to get an input from the user then output the user's input to the cmd.

comment / Description: This is a basic program ask for a user input Then it stores into the eax register And it outputs into the cmd / TITLE getUserInput (getUserInput.asm) INCLUDE Irvine32.inc ;This is where we declare all the data information .data ;Assign values to 32-bit integer storage size variable1 BYTE "Enter a number: ", 0 output BYTE "The number you enter is ", 0 ;This is the main procedure of the program .code main PROC ;Create a cmd console call clrscr ;Move the values in the variable1 into edx mov edx, OFFSET variable1 ;Write the value of variable1 into the console call writestring ;Get the user input call readdec ;Skip line call crlf ;Move the values in the output into edx mov edx, OFFSET output ;Write the value of output into the console call writestring ;Write the user input into the console call writedec ;skip line call crlf exit main endp END main

Click Here To Download Example

Lets work on a more interesting examples. Get two integers from the user, store an integer into a dword which is 32-bits. Then output the sum of the two integers into the console.

comment /
		Description:
				This program get two integers from the user
				It will store the first integer into a dword
				Then it will sum up the two integer
				Finally, output the sum of the two integers
/


				TITLE SumTwoInteger	(SumTwoInt.asm)

					INCLUDE Irvine32.inc

;This is where we declare all the data information

	.data
;Assign String to x
x BYTE "Enter first integer: ", 0

;Assign String to y
y BYTE "Enter second integer: ", 0

;Assign String to output
output BYTE "The sum of two integers: ", 0

;val can hold an unknown 32-bit
val dword ?

;This is the main procedure of the program

	.code
main PROC
	
	;Create a cmd console
	call clrscr

	;Get the first integer from the user
	mov edx, OFFSET x

	;Write the value of x to the console
	call writestring

	;Get the user input
	call readdec

	;Store the user input into val
	mov val, eax

	;Skip line
	call crlf

	;Move the values in y into edx
	mov edx, OFFSET y

	;Write the value of y into the console
	call writestring
	
	;Get the user input
	call readdec

	;Add the first and second integer together
	;Then store the value back into eax
	add eax, val

	;Skip line
	call crlf

	;Move the values of output into edx
	mov edx, OFFSET output

	;Write the values in edx to the console
	call writestring

	;Write the sum of the two integers into the console
	call writedec

	;skip line
	call crlf
	
exit
main endp

END main

Click Here To Download Example

I'm sure you have already notice that whenever we want to write something to the screen we use " writestring, writedec, and so on." Whenever we want to get input from the user we use " readstring, readdec and so on." Hence, keep in mind that whenever we want to print something we use "write" and whenever we want to get something we use "read."

Notice, the add instruction, we add the value of the right into the value of the left, then store the value into the left. Thus, in the above example, we add val to eax, then store the value back into the eax register.

Now we will take a look at loops and condition statements. Here is a table some of the most common condition.

Mnemonic	Description
je	Jump if equal (leftOp = rightOp)
jne	Jump if not equal
jg	Jump if greater (leftOP > rightOp)
jnle	Jump if not less than or equal (same as jg)
jnl	Jump if not less (same as jge)
jnge	Jump if not greater than or equal(same as JL)
jle	Jump if less than or equal(if leftOp <= rightOp)
jng	Jump if not greater(same as jle)
cmp	Compare the right to the left

Okay, here is a simple example of a while loop. It asks the user for three integers, then it will sum up the integers and output the sum of the integers.

comment /
		Description:
				The program use a while loop to get three integers
				Then it sum up the integers and output the sum to the console
			
/


				TITLE WhileLoopSum	(WhileLoopSum.asm)

					INCLUDE Irvine32.inc

;This is where we declare all the data information

	.data

;Assign String to getVal
getVal BYTE "Enter the integer: ", 0

;Assign String to output
output BYTE "The sum the integers: ", 0

;Set the sum equal to 0
sum dword 0

;This is the main procedure of the program

	.code
main PROC
	
	;Create a cmd console
	call clrscr

	;Set the loop counter to 3
	mov ecx, 3

comment *

	Here we create a whileloop that will loop 3 times
	Inside the while loop we will add up the sum
	Then we will use the compare method and jz condition
	It will jump out of the while loop when the counter hits 0

*


while0:
	   ;Compare the counter to 0
	   ;If the counter is 0, jump to end0
	   
	   cmp ecx, 0
	   jz end0

	   ;Get the integer from the user
	   mov edx, OFFSET getVal
	   call writestring
	   call readdec

	   ;Add the user input to the sum
	   ;Store the value back into sum
	   add sum, eax

	   ;Decrement the counter
	   dec ecx

	   ;Jumps back to the beginning of the loop
	   jmp while0

end0:
	   ;Store the sum back into eax
	   mov eax, sum

	   ;Write the sum to the console
	   mov edx, OFFSET output
	   call writestring
	   call writedec

	   ;Skip line
	   call crlf


exit
main endp

END main

Click Here To Download Example

So in the above example, we have two registers. The eax and the ecx register. Recall, whenever we dealing with loops we use the ecx register. The ecx register act as the counter for the loop. In the example, we set the ecx to 3, thus the while loop will loop three times to ask the user for an integer.

Inside the while loop, we use the compare instruction " cmp ". The instruction will compare the ecx register to 0, if the ecx register is 0, we will jump to end0. You can look at end0 as a method, that you only jump to whenever the condition is met.

Notes: while0, it's just a name that we created for the while loop. We can call it whatever names we want. You'll see what I meant as you read on to the examples.

The next example uses a different loop similar to the for loop in java or C++.

comment /
		Description:
				The program use a while loop to get three integers
				Then it sum up the integers and output the sum to the console
			
/


				TITLE WhileLoopSum	(WhileLoopSum.asm)

					INCLUDE Irvine32.inc

;This is where we declare all the data information

	.data

;Assign String to getVal
getVal BYTE "Enter the integer: ", 0

;Assign String to output
output BYTE "The sum the integers: ", 0

;Set the sum equal to 0
sum dword 0

;This is the main procedure of the program

	.code
main PROC
	
	;Create a cmd console
	call clrscr

	;Set the loop counter to 3
	mov ecx, 3

comment *

	Here we create a for loop that will loop 3 times
	Inside the for loop we will add up the sum
	Then we will use the compare method and je condition
	It will jump out of the while loop when ecx equals to 0

*


Loop0:
	   ;Compare the counter to 0
	   ;If the counter is 0, jump to end0
	   
	   cmp ecx, 0
	   je end0

	   ;Get the integer from the user
	   mov edx, OFFSET getVal
	   call writestring
	   call readdec

	   ;Add the user input to the sum
	   ;Store the value back into sum
	   add sum, eax

	   ;Jumps back to the beginning of the loop
	   loop Loop0

end0:
	   ;Store the sum back into eax
	   mov eax, sum

	   ;Write the sum to the console
	   mov edx, OFFSET output
	   call writestring
	   call writedec

	   ;Skip line
	   call crlf


exit
main endp

END main

Click Here To Download Example

In the above example, we created a loop called "Loop0". The only difference between this loop and the while loop is, the while loop we have to decrement the counter (ecx ) by ourself. Whereas this loop, the counter ( ecx ) decrements by itself.

Now lets look at an example on creating an empty array, store elements in the array and accessing the elements in the array.

comment *
		Description:
				The program will ask the user for a series of number
				Then the input will be store into an array
				The numbers in the array will be organize from ascending order
				Then it will print out the number in the array and asterisk
				base on how many match number is in the array
*


					TITLE Array	(Array.asm)

					    INCLUDE Irvine32.inc

	.data
prompt	BYTE "Enter up to 35 numbers [0 - 100. 101 to end]: ", 0	; ask the user for a value
getInput	BYTE "? ", 0
Grade BYTE "Grades", 0

;Set the counter to 35
counter = 35

;Create a 32-bit array that can hold 35 elements of any value
array DWORD counter dup(?)

;Set elementCount to 0
elementCount DWORD 0

	.code
main PROC
	
	;Create a cmd window
	call clrscr

	;Write prompt to the cmd
	mov edx, OFFSET prompt
	call writestring
	call crlf
	
	;Set assign counter to the ecx register where we use for loop counter
	mov ecx, counter

	;Set the array counter to 0
	mov esi, 0

;This loop get the user input

L1:	
	mov edx, OFFSET getInput
	call writestring
	call readdec

	;Jump out of the loop if 101 is entered
	cmp eax, 101
	je L2

	;Each time element is input, increment the number of element in the array
	inc elementCount

	;Store use input into the array
	mov array[esi], eax

	;Move to the next empty location of the array
	add esi, 4

	;Repeat the loop process
	loop L1

L2:
	;Set the pointer back to 0
	mov esi, 0

	;Set the loop counter to the number of element inside the array
	mov ecx, elementCount

	;Print the value from grade
	mov edx, OFFSET Grade
	call writestring
	call crlf

;Using a loop to write out all the elements in the array
L3:
	mov eax, array[esi]
	call writedec
	call crlf

	add esi, 4
	loop L3

exit
main endp

END main

Click Here To Download Example

The main ideas about array is the "ESI" pointer. Array starts at index 0, then increases by 4. Thus, the first element of the array is at 0, then the second one is at 4, third one is at 8, fourth one is at 12, and so on. Thus, when storing elements in the array we have to increment the "ESI" register by 4. Hence, that goes the same when accessing elements from the array.

<Home>