DEPARTMENT OF COMPUTER SCIENCE

Course Title: Computer Organization and Assembly Programming

Individual Assignment on Assembly Programming Language

Section – CCSN13

Name

Abdulmenan Amin UU88987R

Submitted to Girmay G.
What Is Assembly Programming Language?
Assembly language is a low-level programming language that is closely
related to machine code. It is specific to a particular computer architecture
and provides a human-readable representation of the machine instructions
that the computer's processor can execute directly.

In assembly language, instructions are written using mnemonic codes that

represent specific operations, such as arithmetic calculations, memory
access, and control flow. These mnemonic codes are then translated into
machine code, which consists of binary instructions that the computer's
processor can understand and execute.

Assembly language allows programmers to have more control over the

hardware and perform tasks at a very low level. It is often used in situations
where direct hardware manipulation or optimization is required, such as
device drivers, operating systems, embedded systems, and real-time
systems.

How it works?
Assembly language works by providing a human- readable representation of
machine instructions that can be directly executed by a computer's
processor. Here's a simplified overview of how it works:

1. Writing Assembly Code: Programmers write assembly code using

mnemonic instructions that represent specific operations, such as adding
numbers, moving data between memory locations, or branching to different
parts of the code. Each instruction corresponds to a specific machine
instruction.

2. Assembling: The assembly code is then processed by an assembler, which

is a program that translates the assembly code into machine code. The
assembler converts each mnemonic instruction into its corresponding
binary representation, which the computer's processor can understand and
execute.

3. Execution: The resulting machine code is loaded into the computer's

memory and executed by the processor. The processor reads each

1
instruction from memory, performs the specified operation, and updates the
program counter to move to the next instruction. This process continues
until the program completes or encounters a branching instruction that
alters the program flow.

4. Direct Hardware Interaction: Assembly language allows programmers to

directly interact with the computer's hardware. They can access specific
memory locations, manipulate registers, control input/output devices, and
perform other low-level operations. This level of control is useful for tasks
that require fine-grained control over hardware resources, such as device
drivers or operating system development.

It's important to note that assembly language is specific to a particular

computer architecture. Each processor family has its own instruction set
and assembly language syntax. Therefore, assembly code written for one
architecture may not work on another without modification.

What are the components?

In assembly language programming, there are several key components that
make up the programming environment. These components include:

1. Mnemonic Instructions: Assembly language uses mnemonic instructions

to represent specific operations that the computer's processor can execute.
These instructions are human-readable representations of machine
instructions. Examples of mnemonic instructions include ADD (addition),
MOV (move data), JMP (jump to a different part of the code), and CMP
(compare values).

2. Registers: Registers are small, high-speed memory locations within the

processor that can hold data or addresses. Assembly language programs
often use registers to perform calculations, store intermediate results, and
manipulate data. Registers have specific names and purposes, such as the
accumulator (for arithmetic operations), the program counter (to keep track
of the current instruction), and general-purpose registers (for storing data).

3. Memory: Assembly language programs interact with memory to store and

retrieve data. Memory is a large, linear array of storage locations, each with
a unique address. Assembly language instructions can access memory
locations directly by specifying the memory address. Memory is used to

2
store program instructions, data variables, and other information needed by
the program.

4. Labels and Symbols: Assembly language allows programmers to use

labels and symbols to represent memory addresses or specific locations in
the code. Labels are typically used for branching instructions or to mark
specific sections of the code. Symbols can be used to represent constants or
variables, making the code more readable and maintainable.

5. Directives: Assembly language includes directives, which are instructions

to the assembler rather than the processor. Directives provide information
to the assembler about how to assemble the code, such as defining
constants, allocating memory, or including external libraries.

6. Assembler: The assembler is a program that translates assembly code

into machine code. It reads the assembly code, processes the instructions,
and generates the corresponding machine code. The assembler also handles
tasks such as resolving labels and symbols, allocating memory, and
generating the necessary data structures for the program.

These components work together to create an assembly language

programming environment, allowing programmers to write low-level code
that can be directly executed by the computer's processor.

Samples of assembly programming language code

Sample code one
section .data

message db 'Hello, World!', 0

section .text

global _start

_start:

; Write the message to the standard output

mov eax, 4 ; System call number for write

3
 mov ebx, 1 ; File descriptor for standard output

mov ecx, message ; Address of the message

mov edx, 13 ; Length of the message

int 0x80 ; Call the kernel

; Exit the program

mov eax, 1 ; System call number for exit

xor ebx, ebx ; Exit status code 0

int 0x80 ; Call the kernel

In this example, the code prints the message "Hello, World!" to the standard
output and then exits. Let's break it down:

 The .data section is used to declare data variables. In this case, we

define a null-terminated string called message that holds the text
"Hello, World!".
 The .text section contains the actual code instructions. The _start
label marks the entry point of the program.
 The first part of the code uses the mov instruction to set up the
parameters for the write system call. It loads the appropriate values
into registers eax, ebx, ecx, and edx. The int 0x80 instruction triggers
a software interrupt, which transfers control to the kernel to perform
the system call.
 After printing the message, the code sets up the parameters for the
exit system call and calls it to terminate the program.

Assembly code can vary depending on the specific architecture and

assembler being used. The above example is for x86 assembly language
using the NASM assembler.

Sample code two

 this time for the ARM architecture using the GNU Assembler (GAS)
syntax:

4
.data

message: .asciz "Hello, World!\n"

.text

.global _start

_start:

; Write the message to the standard output

mov r0, #1 @ File descriptor for standard output

ldr r1, =message @ Address of the message

ldr r2, =14 @ Length of the message

mov r7, #4 @ System call number for write

swi 0 @ Call the kernel

; Exit the program

mov r7, #1 @ System call number for exit

mov r0, #0 @ Exit status code 0

swi 0 @ Call the kernel

In this example, the code performs the same task as the previous example:
it prints the message "Hello, World!" to the standard output and then exits.
However, this code is written for the ARM architecture using the GAS
syntax.

Here's a breakdown of the code:

 The .data section is used to declare data variables. In this case, we

define a null-terminated string called message that holds the text
"Hello, World!\n".

5
  The .text section contains the actual code instructions. The _start label
marks the entry point of the program.
 The code uses ARM-specific instructions to set up the parameters for
the write system call. It loads the appropriate values into registers r0,
r1, r2, and r7. The swi 0 instruction triggers a software interrupt,
which transfers control to the kernel to perform the system call.
 After printing the message, the code sets up the parameters for the
exit system call and calls it to terminate the program.

The above example is for ARM assembly language using the GNU Assembler
(GAS) syntax.

Sample code three

 this time for the MIPS architecture using the MARS simulator:

.data

message: .asciiz "Hello, World!\n"

.text

.globl main

main:

# Write the message to the standard output

li $v0, 4 # System call number for print_string

la $a0, message # Address of the message

syscall # Call the kernel

# Exit the program

li $v0, 10 # System call number for exit

syscall # Call the kernel

In this example, the code performs the same task as the previous examples:
it prints the message "Hello, World!" to the standard output and then exits.

6
However, this code is written for the MIPS architecture using the MARS
simulator.

Here's a breakdown of the code:

 The .data section is used to declare data variables. In this case, we

define a null-terminated string called message that holds the text
"Hello, World!\n".
 The .text section contains the actual code instructions. The main label
marks the entry point of the program.
 The code uses MIPS-specific instructions to set up the parameters for
the print_string system call. It loads the appropriate values into
registers $v0 and $a0. The syscall instruction triggers a system call,
which transfers control to the kernel to perform the system call.
 After printing the message, the code sets up the parameters for the
exit system call and calls it to terminate the program.

The above example is for MIPS assembly language using the MARS
simulator.

Advantages of assembly programming language

1. Efficiency: Assembly language allows for direct control over the
hardware, enabling programmers to write highly optimized and efficient
code. It provides fine-grained control over the processor's resources,
resulting in faster and more efficient programs.

2. Low-level Access: Assembly language provides direct access to the

underlying hardware, allowing programmers to utilize specific features and
instructions that may not be available in higher-level languages. This level
of control is beneficial for tasks such as device drivers, operating systems,
and embedded systems programming.

3. Portability: Assembly language programs can be written to be highly

portable across different platforms and architectures. While the syntax may
differ, the underlying concepts and instructions remain similar, making it
easier to adapt code to different systems.

4. Debugging Capabilities: Assembly language programs offer detailed

visibility into the system's internal state, making it easier to debug and

7
trace program execution. This level of control is particularly useful for
diagnosing low-level issues and optimizing performance.

5. Direct Memory Access: Assembly language provides direct access to

memory, allowing programmers to manipulate data at a low level. This can
be advantageous for tasks that require precise memory management, such
as operating systems or real-time systems.

6. Hardware-specific Optimization: Assembly language allows programmers

to take advantage of specific hardware features and optimizations. This
level of control can result in highly efficient code that is tailored to the
target architecture, maximizing performance.

Disadvantages of assembly programming language

1. Steep Learning Curve: Assembly language is considered a low-level
language, and its syntax and concepts can be complex and challenging to
grasp for beginners. It requires a deep understanding of computer
architecture and hardware.

2. Time-consuming Development: Writing programs in assembly language is

generally more time-consuming compared to higher-level languages.
Assembly code is verbose and requires explicit instructions for even simple
tasks, making development and maintenance more labor-intensive.

3. Lack of Abstraction: Assembly language lacks the high-level abstractions

and features found in modern programming languages. This can make code
harder to read, understand, and maintain, as programmers need to handle
low-level details explicitly.

4. Platform Dependency: Assembly language programs are often tightly

coupled to a specific hardware architecture, making them less portable
across different systems. Porting assembly code to a different platform may
require significant modifications or a complete rewrite.

5. Maintenance and Readability: Assembly code can be difficult to read and

understand, especially for programmers who are not familiar with low-level
programming. This can make maintenance and collaboration on assembly
projects more challenging.

6. Limited Abstraction: Assembly language lacks the high-level abstractions

and data structures found in modern programming languages. This can

8
make complex algorithms and data manipulation more cumbersome to
implement and maintain.

7. Error-Prone: Assembly language programming is highly susceptible to

human error. Due to the lack of built-in safety features and the need for
manual memory management, bugs and errors can easily occur, leading to
crashes or security vulnerabilities.

8. Development Time: Writing programs in assembly language typically

requires more time and effort compared to higher-level languages. The need
to manually handle low-level details and write explicit instructions can slow
down the development process.