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

Control Unit: The manager of the CPU, decodes instructions and controls the operations done by the ALU 2. Arithmetic Logic Unit: Arithmetic and logic operations are carried out. 3. Instruction register: Stores a copy of the current instruction being executed 4. program counter: Stores the address of the next instruction in the program to be executed 5. Bus: Transfer of data
1.

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
value

register

(a

temporary

STO 10
the accumulator) to a memory location, which in this case is 10.

location in the CPU) to a fixed This will store a result (found in

Move

data

from

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 data from

hardware devices

INP ah, 145

Receives input from the input

device with the code 145 and

stores it into register ah.

Computing Data
Add, divide register subtract, the multiply, of or two values

ADD AX, BX
Add the contents found in the register AX with the contents in register BX and store the result

registers, placing the result in a

in register AX.
Perform taking disjunction bitwise the operations, / of

conjunction (and/or)

OR AX, BX
Executes a bit-wise OR between
the two registers and stores the result in BX.

corresponding bits in a pair of registers, or the negation (not) 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 destination to 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 0001 0010 0010

LDA STA ADD SUB

address. STore Accumulator contents in specified address.

ADD contents of the specified address to the

accumulator. SUBtract contents of specified address from the accumulator.

0110
0111 1001 1010

JPU
JAZ JAL JAG

JumP Unconditionally to the specified address

Jumps to the specified address if Accumulator is Zero. Jumps to specified address if Accumulator < zero.

Jumps to the specified address if the Accumulator

> zero.

Addressing

With Assembly Language, we have three ways in which the computer can find locations from memory;

1.
2. 3.

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 11 12 13

LDA 10

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 Bx+2 Bx+3 Bx+4

MOV CX,[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 107

LDA NUM1

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

2. 3. 4.

command jmp lab1 is encountered, the program will jump to the label The program will continue from the label The commands add ax,4 and lda 10 will be skipped 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 jumps criteria

1. Assembly cmp ax, bx

2.

jg isgreater
: ; block 1 (else part)

jmp after isgreater: : ; block 2 (then part) 3.

after: : ; after if

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
Jump if greater Jump if greater or equal Jump if less Jump if less or equal Jump if equal Jump if not equal

jg jge jl jle je jne

jc

Jump if carry flag is set