The CPU Revision Typical machine code instructions Using op-codes and operands Symbolic addressing....
-
Upload
oliver-weaver -
Category
Documents
-
view
225 -
download
1
Transcript of The CPU Revision Typical machine code instructions Using op-codes and operands Symbolic addressing....
The CPURevision Typical machine code instructions Using op-codes and operands Symbolic addressing. Conditional and unconditional branches
The CPUThe 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. 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
Assembly Language The CPU uses what is known as
Assembly Language
Assembly Language is made up of op-codes and operands
Instructions in assembly language are rather simple
Assembly Language Operations
A few examples
Moving Data Set a register (a temporary
location in the CPU) to a fixed
value
STO 10This will store a result (found in
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
on it later, or to store the result
of a computation.
mov ah, 09This will move the constant
number 9 to the register ah.
Read and write data from
hardware devicesINP ah, 145Receives input from the input
device with the code 145 and
stores it into register ah.
Computing Data Add, subtract, multiply, or
divide the values of two
registers, placing the result in a
register
ADD AX, BXAdd the contents found in the
register AX with the contents in
register BX and store the result
in register AX.
Perform bitwise operations,
taking the conjunction /
disjunction (and/or) of
corresponding bits in a pair of
registers, or the negation (not)
of each bit in a register
OR AX, BXExecutes a bit-wise OR between
the two registers and stores the
result in BX.
Compare two values in registers
(for example, to see if one is
less, or if they are equal)
CMP AX, BXCompares 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 destThis will force the flow of the
program to jump to the
destination specified as an
argument.
Jump to another location if a
certain condition holdsJNZ destThis 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
0000 LDA
LOAD Accumulator with contents of specified
address.
0001 STA STore Accumulator contents in specified address.
0010 ADD
ADD contents of the specified address to the
accumulator.
0010 SUB
SUBtract contents of specified address from the
accumulator.
0110 JPU JumP Unconditionally to the specified address
0111 JAZ
Jumps to the specified address if Accumulator is
Zero.
1001 JAL Jumps to specified address if Accumulator < zero.
1010 JAG
Jumps to the specified address if the Accumulator
> zero.
1111 HLT Stop the program
Addressing With Assembly Language, we
have three ways in which the computer can find locations from memory;
1. Absolute Addressing2. Relative Addressing3. 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)
910 11 12 13
LDA 10
Relative AddressingThis 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)
BxBx+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 107
LDA NUM1
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 JumpThis 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, 5jmp lab1add ax, 4lda 10lab1: 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 label3. The commands add ax,4 and lda 10 will
be skipped4. 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
Assembly
cmp ax, bx
jg isgreater
: ; block 1 (else part)
jmp after
isgreater:
: ; block 2 (then part)
after:
: ; after if
1. The registers ax and bx are compared with each other using the command CMP
2. 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
3. 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