Page 27 - DCAP210_INTRODUCTION__TO_MICROPROCESSORS

Unit 2: Introduction to Assembly Language

Before we can explore the process of writing computer programs, we have to go back to the Notes
basics and learn exactly what a computer is and how it works. Every computer, no matter how
simple or complex, has at its heart exactly two things: a CPU and some memory. Together, these
two things are what make it possible for your computer to run programs.
On the most basic level, a computer program is nothing more than a collection of numbers stored
in memory. Different numbers tell the CPU to do different things. The CPU reads the numbers
one at a time, decodes them, and does what the numbers say. For example, if the CPU reads the
number 64 as part of a program, it will add 1 to the number stored in a special location called AX.
If the CPU reads the number 146, it will swap the number stored in AX with the number stored in
another location called BX. By combining many simple operations such as these into a program,
a programmer can make the computer perform many incredible things.
As an example, here are the numbers of a simple computer program: 184, 0, 184, 142, 216, 198, 6,
158, 15, 36, 205, 32.

2.1 Assembly Language
Although the numbers of the above program make perfect sense to a computer, they are about as
clear as mud to a human. Who would have guessed that they put a dollar sign on the screen?
Clearly, entering numbers by hand is a lousy way to write a program.

It doesn’t have to be this way, though. A long time ago, someone came up with the idea that
computer programs could be written using words instead of numbers. A special program called
an assembler would then take the programmer’s words and convert them to numbers that the
computer could understand. This new method, called writing a program in assembly language,
saved programmers thousands of hours, since they no longer had to look up hard-to-remember
numbers in the backs of programming books, but could use simple words instead.

The program above, written in assembly language, looks like this:
MOV AX, 47104
MOV DS, AX
MOV [3998], 36
INT 32

When an assembler reads this sample program, it converts each line of code into one CPU-level
instruction. This program uses two types of instructions, MOV and INT. On Intel processors, the
MOV instruction moves data around, while the INT instruction transfers processor control to the
device drivers or operating system.

The program still isn’t quite clear, but it is much easier to understand than it was before. The first
instruction, MOV AX, 47104, tells the computer to copy the number 47104 into the location AX.
The next instruction, MOV DS, AX, tells the computer to copy the number in AX into the location
DS. The next instruction, MOV [3998], 36 tells the computer to put the number 36 into memory
location 3998. Finally, INT 32 exits the program by returning to the operating system.
Before we go on, we would like to explain just how this program works. Inside the CPU are a
number of locations, called registers, which can store a number. Some registers, such as AX, are
general purpose, and don’t do anything special. Other registers, such as DS, control the way the
CPU works. DS just happens to be a segment register, and is used to pick which area of memory
the CPU can write to. In our program, we put the number 47104 into DS, which tells the CPU to
access the memory on the video card. The next thing our program does is to put the number 36
into location 3998 of the video card’s memory. Since 36 is the code for the dollar sign, and 3998 is
the memory location of the bottom right-hand corner of the screen, a dollar sign shows up on the
screen a few microseconds later. Finally, our program tells the CPU to perform what is called an

LOVELY PROFESSIONAL UNIVERSITY 21