Download Exp1 - WordPress.com

Assignment 1:
Problem Definition:
Write X86/64 Assembly language program (ALP) to add array of N hexadecimal numbers stored
in the memory. Accept input from the user.
1.1 Prerequisites: Concepts of
1. Program
2. Algorithm
3. Registers
4. Assembly language
5. Assembler
6. Array & its scope
1.2 Learning Objectives:
1. Understand the implementation
2. Understand the implementation of the arithmetic instruction of 80386.
1.3 New concepts:1.3.1 What is ALP?
Assembly language Program is mnemonic representation of machine code.
1.3.2 Which assembler used in execution of ALP?
Three assemblers available for assembling the programs for IBM-PC are:
1. Microsoft Micro Assembler (MASM)
2. Borland Turbo Assembler (TASM)
3. Net wide Assembler (NASM)
1.4 Theory
1.4.1 Assembly Basic Syntax
An assembly program can be divided into three sections:
1. The data section
2. The bss section
3. The text section
The data Section
The data section is used for declaring initialized data or constants. This data does not change at
runtime. You can declare various constant values, file names or buffer size etc. in this section.
The syntax for declaring data section is:
section .data
1
The bss Section
The bss section is used for declaring variables. The syntax for declaring bss section is:
section .bss
The text section
The text section is used for keeping the actual code. This section must begin with the declaration
global main, which tells the kernel where the program execution begins.
The syntax for declaring text section is:
section .text
global main
main:
1.4.2 Assembly Language Statements
Assembly language programs consist of three types of statements:
1. Executable instructions or instructions
2. Assembler directives or pseudo-ops
3. Macros
The executable instructions or simply instructions tell the processor what to do. Each
instruction consists of an operation code (opcode). Each executable instruction generates one
machine language instruction.
The assembler directives or pseudo-ops tell the assembler about the various aspects of the
assembly process.
These are non-executable and do not generate machine language instructions.
Macros are basically a text substitution mechanism.
1.4.3 Assembly System Calls
System calls are APIs for the interface between user space and kernel space. We are using the
system calls sys_write and sys_exit for writing into the screen and exiting from the program
respectively.
Linux System Calls
You can make use of Linux system calls in your assembly programs. You need to take the
following steps for using Linux system calls in your program:
 Put the system call number in the EAX register.
 Store the arguments to the system call in the registers EBX, ECX, etc.
 Call the relevant interrupt (80h)
 The result is usually returned in the EAX register
There are six registers that stores the arguments of the system call used. These are the EBX,
ECX, EDX, ESI, EDI, and EBP. These registers take the consecutive arguments, starting with
the EBX register. If there are more than six arguments then the memory location of the first
argument is stored in the EBX register.
The following code snippet shows the use of the system call sys_exit:
MOV EAX, 1
; system call number (sys_exit)
INT 0x80
; call kernel
2
The following code snippet shows the use of the system call sys_write:
MOV EDX, 4
; message length
MOV ECX, MSG ; message to write
MOV EBX,1
; file descriptor (stdout)
MOV EAX,4
; system call number (sys_write)
INT 0x80
; call kernel
The following table shows some of the system calls:
1.4.4 Assembly Variables
NASM provides various define directives for reserving storage space for variables. The define
Assembler directive is used for allocation of storage space. It can be used to reserve as well as
initialize one or more bytes.
Allocating Storage Space for Initialized Data
There are five basic forms of the define directive:
Allocating Storage Space for Uninitialized Data
3
The reserve directives are used for reserving space for uninitialized data. The reserve directives
take a single operand that specifies the number of units of space to be reserved. Each define
directive has a related reserve directive.
There are five basic forms of the reserve directive:
1.5 Instructions needed:
1. MOV-Copies byte or word from specified source to specified destination
2. ROR-Rotates bits of byte or word right, LSB to MSB and to CF
3. AND-AND each bit in a byte or word with corresponding bit in another byte or word
4. INC-Increments specified byte/word by 1
5. DEC-Decrements specified byte/word by 1
6. JNZ-Jumps if not equal to Zero
7. JNC-Jumps if no carry is generated
8. CMP-Compares to specified bytes or words
9. JBE-Jumps if below of equal
10. ADD-Adds specified byte to byte or word to word
11. CALL-Transfers the control from calling program to procedure.
12. RET-Return from where call is made
1.6 Algorithm:
1. Start
2. Initialize data section
3. Load counter with number element for Addition
4. Locate first location of array of Number in Pointer Register.
5. Initialize result-low and result high to 00
6. Scan the number from user and convert it into Hex
7. Increment Location Pointer Register.
8. Decrement counter
9. Jump to step 6 if counter is not zero
10. Locate first location of array of numbers in a pointer register
11. Initialize counter with number of elements for addition
12. Add the element of array pointed by pointer register
13. Check the carry of addition. If carry is generated then go to step 14 else go to step15
14. Increment result-high register
15. Increment pointer register to array
16. Decrement counter
17. Jump to step 12 if counter is not equal to zero
4
18. Display the content of Result-High as carry of addition by converting hex to ASCII
19. Display the content of Result-Low as result of addition by converting hex to ASCII
20. Stop
1.7 Mathematical Equation:
𝑵=∑
𝒏𝟏 + 𝒏𝟐 + ⋯ . . +𝒏 − 𝟏
Where:
N=32 bit Result
n= 16 bit Numbers in Series.
1.8 Working with ALP in NASM
NASM - The Netwide Assembler
1. an 80x86 and x86-64 assembler designed for portability and modularity
2. Supports a range of object file formats - a.out, ELF, COFF, OBJ, WIN32, WIN64, etc.
3. Default format - binary can read, combine and write object files in many different
formats such as COFF, ELF, etc
4. Different formats may be linked together to produce any available kind of object file.
5. Elf – executable & linkable file format of object file & executable file – supported by
Linux
Commands
• To assemble
nasm –f
•
elf64 hello.asm
To link
ld –o hello hello.o
•
To execute ./hello
1.9 Conclusion
5