Transcript The CPU

The CPU
Revision
Typical machine code instructions
Using op-codes and operands
Symbolic addressing.
Conditional and unconditional branches
The CPU

The Central Processing Unit is one of the
main parts of a computer
It consists of;
1. Control Unit (CU)
2. The Arithmetic Logic Unit (ALU)
3. Registers

Structure of the CPU
Arithmetic Logic Unit
Accumulator
Control Unit
Program Counter
Instruction Register
Parts of the CPU
1.
2.
3.
4.
5.
Control Unit: The manager of the CPU,
decodes instructions and controls the
operations done by the ALU
Arithmetic Logic Unit: Arithmetic and logic
operations are carried out.
Instruction register: Stores a copy of the
current instruction being executed
program counter: Stores the address of the
next instruction in the program to be
executed
Bus: Transfer of data
Assembly Language

The CPU uses what is known as Assembly
Language

Assembly Language is made up of opcodes and operands

Instructions in assembly language are
rather simple
Assembly Language
Operations
A few examples
Moving Data
Set
a
register
(a
temporary
STO 10
location in the CPU) to a fixed This will store a result (found in
value
the accumulator) to a memory
location, which in this case is 10.
Move
data
from
a
memory
location to a register, or vice
versa. This is done to obtain the
data to perform a computation
mov ah, 09
This
will
move
the
constant
number 9 to the register ah.
on it later, or to store the result
of a computation.
Read
and
write
hardware devices
data
from
INP ah, 145
Receives input from the input
device with the code 145 and
stores it into register ah.
Computing Data
Add,
subtract,
divide
the
multiply,
values
of
or
two
registers, placing the result in a
register
ADD AX, BX
Add the contents found in the
register AX with the contents in
register BX and store the result
in register AX.
Perform
taking
bitwise
the
disjunction
operations,
conjunction
(and/or)
/
of
corresponding bits in a pair of
registers, or the negation (not)
OR AX, BX
Executes a bit-wise OR between
the two registers and stores the
result in BX.
of each bit in a register
Compare
two
values
in
registers (for example, to see if
one is less, or if they are equal)
CMP AX, BX
Compares
the
values
by
subtracting the BX from AX, the
result is not stored.
Program Flow
Jump to another location in the
program
and
execute
instructions there
JMP dest
This will force the flow of the
program
to
destination
jump
specified
to
as
the
an
argument.
Jump to another location if a
certain condition holds
JNZ dest
This
will
jump
to
the
destination if the accumulator
is not Zero.
For more info:
http://en.wikibooks.org/wiki/X86_Assembly/X86_Instructions
Using Op-Codes (mnemonics)

Op-Codes are used instead of binary

Op - Codes are short words normally
made up of 3 characters

When used they perform a function

Op-Codes are easier to remember by
programmers, since their name refers to
what they will perform
Op – Code Examples
Op.code
(binary)
Mnemonic Function
LOAD Accumulator with contents of specified
0000
LDA
address.
0001
STA
STore Accumulator contents in specified address.
ADD contents of the specified address to the
0010
ADD
accumulator.
SUBtract contents of specified address from the
0010
SUB
accumulator.
0110
JPU
JumP Unconditionally to the specified address
Jumps to the specified address if Accumulator is
0111
JAZ
Zero.
1001
JAL
Jumps to specified address if Accumulator < zero.
Jumps to the specified address if the Accumulator
1010
JAG
> zero.
Addressing

1.
2.
3.
With Assembly Language, we have three
ways in which the computer can find
locations from memory;
Absolute Addressing
Relative Addressing
Symbolic Addressing
Absolute Addressing

When we use Assembly Language different
memory locations are used

In some cases we can actually specify which
memory location we wish to use (example, LDA
10 is specifying that the accumulator should be
filled with the contents found in memory location
10)
9
10
LDA 10
11
12
13
Relative Addressing

This is indicated by specifying the distance from
another address

In this case it is called the base address, hence the
exact memory location is not given (example,
MOV CX, [BX+4] is specifying that the contents
of Register C must be moved in the location
which is found 4 locations off register B)
Bx
Bx+1
MOV CX,[BX+4]
Bx+2
Bx+3
Bx+4
Note:
BX is the base address
Symbolic Addressing

A label can be given to a memory location in
assembly language

Instead of referring to the memory location by the
location a label is used.

The memory location 106 can be assigned a label
Num1, and from then on, whenever location 106 is
required, instead of calling memory location 106,
Num1 is called, LDA Num1.
103
104
105
106
NUM1
LDA NUM1
107
Conditional & Unconditional branches

The program counter (PC) found in the CPU points
to the next instruction to be fetched

If we change the PC, instructions can be executed in a
different order not in a sequence

In order to use jump instructions, labels must be
used. Labels can be created by simply specifying a
label name and adding a colon at the end of the label.
For example:
label1: mov ax,5
mov bx,3
Unconditional Jump
This type of branching instructs the
processor to jump to a label without any
conditions.
 The command is JMP

When the JMP command
is encountered, the flow
of the program will
resume from the
specified label; in this
case lab1.
mov ax, 5
jmp lab1
add ax, 4
lda 10
lab1: sub ax, 3
…
 In the program,;
1. As soon as the
command jmp lab1 is
encountered, the program will jump to the
label
2. The program will continue from the label
3. The commands add ax,4 and lda 10 will be
skipped
4. sub ax,3 will be worked next.

As already mentioned, an unconditional
branch does not have any conditions, so
when the jump command is encountered it
will simply skip to the label.
Conditional Branching

Conditional branching allows the program to
skip to another location (through the use of
labels) only if it satisfies a condition

In order to use this type of branching, a
comparison must be done first

First we carry out the comparison, and then
we jump to a label if the comparison satisfies
the jump’s criteria
1.
Assembly
cmp ax, bx
2.
jg isgreater
:
; block 1 (else part)
jmp after
isgreater:
:
; block 2 (then part)
after:
:
; after if
3.
The registers ax and bx
are compared with each
other using the
command CMP
Then the command jg
(jump if greater) is used
to jump to the label
isgreater, if ax is greater
than bx, otherwise it will
jump to label after
The actual comparison is
carried out using the
CMP command, and
then different jump
statements can be used.
Different Jumps
Instruction
Meaning
jg
Jump if greater
jge
Jump if greater or equal
jl
Jump if less
jle
Jump if less or equal
je
Jump if equal
jne
Jump if not equal
jc
Jump if carry flag is set