Instruction Set Architecture

Nizamettin AYDIN
naydin@yildiz.edu.tr
http://www.yildiz.edu.tr/~naydin
C Fortran Ada etc. Basic Java

Compiler
Compiler Compiler
Compiler

Assembly Language Byte Code

Assembler
Assembler Interpreter
Interpreter

Executable

Instruction Set Architecture

HW HW HW
Implementation 1 Implementation 2 Implementation N
Instruction Set
• Instruction: Language of the machine

• Instruction set: Vocabulary of the language (Collection of

instructions that are understood by a CPU)
lda, sta, brp, jmp, nop, ... (VVM)

• Machine Code
— machine readable
— Binary(example: 1000110010100000)

• Usually represented by assembly codes

— Human readable
— Example: VVM code adding a number entered from keyboard
and a number in memory location 40
0 in
1 sta 30
2 add 40
3 sta 50
4 hlt
Instruction Types
• Data processing
—ADD, SUB

• Data storage (main memory)

—STA

• Data movement (I/O)

—IN, OUT, LDA

• Program flow control

—BRZ
Elements of an Instruction
• Operation code (Op-code)
—Do this
—Example: ADD 30 (VVM code)
• Source Operand reference
—To this
—Example: LDA 50 (VVM code)
• Result Operand reference
—Put the result here
—Example: STA 60 (VVM code)
• Next Instruction Reference
—When you have done that, do this...
—PC points to the next instruction
Source and Result Operands
• Source and Result Operands can be in one
of the following areas:

—Main memory

—Virtual memory

—Cache

—CPU register

—I/O device
Instruction Representation
• In machine code each instruction has a
unique bit pattern
• For human consumption a symbolic
representation is used (assembly language)
• Opcodes are represented by abbreviations,
called mnemonics indicating the operation
— ADD, SUB, LDA, BRP, ...
• In an assembly language, operands can also
be represented as following
—ADD A,B (add contents of B and A and save
the result into A)
Simple Instruction Format
• Following is a 16 bit instruction format

• So...
—What is the maximum number of instructions
in this processor?
—What is the maximum directly addressable
memory size?
Instruction Set Classification
• One way
—Number of operands for typical arithmetic
instruction
add $s1, $s2, $s3
3
—What are the possibilities?

—Will use this C statement as an example:

a = b + c;
—Assume a, b and c are in memory
Zero Address Machine
• a.k.a. Stack Machines

• Example: a = b + c;

PUSH b # Push b onto stack

PUSH c # Push c onto stack
ADD # Add top two items
# on stack and replace
# with sum
POP a # Remove top of stack
# and store in a
One Address Machine
• a.k.a. Accumulator Machine
• One operand is implicitly the accumulator

• Example: a = b + c;

LOAD b # ACC  b
ADD c # ACC  ACC + c
STORE a # a  ACC

• A good example for such a machine is...

VVM
Two Address Machine (1)
• a.k.a. Register-Memory Instruction Set
• One operand may be a value from
memory
• Machine has n general purpose registers
—$0 through $n-1

• Example: a = b + c;

LOAD $1, b # $1  M[b]

ADD $1, c # $1  $1 + M[c]
STORE $1, a # M[a]  $1
Two Address Machine (2)
• a.k.a. Memory-Memory Machine
• Another possibility do stuff in memory!
• These machines have registers used to
compute memory addresses
• 2 addresses (One address doubles as
operand and result)

• Example: a = b + c;

MOVE a, b # M[a]  M[b]

ADD a, c # M[a]  M[a] + M[c]
Two Address Machine (3)
• a.k.a. Load-Store Instruction Set or
Register-Register Instruction Set
• Typically can only access memory using
load/store instructions

• Example: a = b + c;

LOAD $1, b # $1  M[b]

LOAD $2, c # $2  M[c]
ADD $1, $2 # $1  $1 + $2
STORE $1, a # M[a]  $1
Three Address Machine
• a.k.a. Load-Store Instruction Set or Register-
Register Instruction Set
• Typically can only access memory using
load/store instructions
• 3 addresses (Operand 1, Operand 2, Result)
— May be a forth - next instruction (usually implicit)
— Needs very long words to hold everything

• Example: a = b + c;

LOAD $1, b # $1  M[b]

LOAD $2, c # $2  M[c]
ADD $3, $1, $2 # $3  $1 + $2
STORE $3, a # M[a]  $3
Utilization of Instruction Addresses
(Nonbranching Instructions)
 History
Hardware Expensive Hardware Less Hardware and Memory
Memory Expensive Expensive Cheap
Memory Expensive
Accumulators Microprocessors
Register Oriented Compilers getting good
EDSAC Machines (2 address)
IBM 701 Register-Memory CISC
IBM 360 VAX
DEC PDP-11 Motorola 68000
Also Intel 80x86
Fringe Element RISC
Berkley RISCSparc
Stack Machines Dave Patterson
Burroughs B-5000 Stanford MIPS SGI
(Banks) John Hennessy
IBM 801

1940 1950 1960 1970 1980 1990

Performans (which one is better?)
• More addresses
—More complex (powerful?) instructions
—More registers
– Inter-register operations are quicker
—Fewer instructions per program

• Fewer addresses
—Less complex (powerful?) instructions
—More instructions per program
—Faster fetch/execution of instructions
Types of Operand

• Addresses
—Operand is in the address
• Numbers (actual operand)
—Integer or fixed point
—floating point
—decimal
• Characters (actual operand)
—ASCII etc.
• Logical Data (actual operand)
—Bits or flags
Pentium Data Types

• 8 bit (byte), 16 bit (word), 32 bit (double

word), 64 bit (quad word)

• Addressing in Pentium is by 8 bit units

• A 32 bit double word is read at addresses
divisible by 4:
0100 1A 22 F1 77
+0 +1 +2 +3
Specific Data Types
• General - arbitrary binary contents
• Integer - single binary value
• Ordinal - unsigned integer
• Unpacked BCD - One digit per byte
• Packed BCD - 2 BCD digits per byte
• Near Pointer - 32 bit offset within segment
• Bit field
• Byte String
• Floating Point
Pentium
Numeric
Data
Formats
PowerPC Data Types
• 8 (byte), 16 (halfword), 32 (word) and 64
(doubleword) length data types
• Fixed point processor recognises:
—Unsigned byte, unsigned halfword, signed
halfword, unsigned word, signed word,
unsigned doubleword, byte string (<128 bytes)
• Floating point
—IEEE 754
—Single or double precision
Types of Operation

• Data Transfer
• Arithmetic
• Logical
• Conversion
• I/O
• System Control
• Transfer of Control
Data Transfer
• Need to specify
—Source
—Destination
—Amount of data

• May be different instructions for different

movements

• Or one instruction and different addresses

Arithmetic
• Basic arithmetic operations are...
— Add
— Subtract
— Multiply
— Divide
— Increment (a++)
— Decrement (a--)
— Negate (-a)
— Absolute

• Arithmetic operations are provided for...

— Signed Integer
— Floating point?
— Packed decimal numbers?
Logical
• Bitwise operations
• AND, OR, NOT
—Example1: bit masking using AND operation
– (R1) = 10100101
– (R2) = 00001111
– (R1) AND (R2) = 00000101

—Example2: taking ones coplement using XOR

operation
– (R1) = 10100101
– (R2) = 11111111
– (R1) XOR (R2) = 01011010
Basic Logical Operations
Shift and Rotate
Operations
Examples of Shift and Rotate
Operations
An example

• Suppose we wish to transmit characters of

data to an I/O device 1 character at a
time.
• If each memory word is 16 bits in length
and contains two characters, we must
unpack the characters before they can be
sent.
To send the two characters in a word

• Load the word into a register

• AND with the value 1111111100000000
— This masks out the character on the right
• Shift to the right eight times
—This shifts the remaining character to the right
half of the register
• Perform I/O
—The I/O module reads the lower-order 8 bits
from the data bus.
To send the two characters in a word

The preceding steps result in sending the

left-hand character.

To send the right-hand character:

• Load the word again into the register

• AND with 0000000011111111
• Perform I/O
Conversion

• Conversion instructions are those that

change the format or operate on the
format of data.

• For example:
—Binary to Decimal conversion
Input/Output

• May be specific instructions

—IN, OUT

• May be done using data movement

instructions (memory mapped)

• May be done by a separate controller

(DMA)
Systems Control

• Privileged instructions

• CPU needs to be in specific state

• For operating systems use

Transfer of Control
• Branch
—For example: brz 10 (branch to 10 if result is
zero)

• Skip
—e.g. increment and skip if zero
—ISZ Register1
—Branch xxxx
—ADD A

• Subroutine call
—c.f. interrupt call
Branch Instruction
Nested Procedure Calls
Use of Stack
Types of
Operation
Types of
Operation
CPU Actions for Various Types of Operations
Pentium Operation
Types
Pentium Condition Codes
Pentium Conditions for Conditional Jump and
SETcc Instructions
MMX
Instruction Set
PowerPC
Operation Types
PowerPC Operation Types
Byte Ordering

• How should bytes within multi-byte word

be ordered in memory?

• Some conventions
—Sun’s, Mac’s are “Big Endian” machines
– Least significant byte has highest address
—Alphas, PC’s are “Little Endian” machines
– Least significant byte has lowest address
Byte Ordering Example
• Big Endian
—Least significant byte has highest address
• Little Endian
—Least significant byte has lowest address
• Example
—Variable x has 4-byte representation
0x01234567
—Address given by &x is 0x100
Big Endian 0x100 0x101 0x102 0x103
01 23 45 67

Little Endian 0x100 0x101 0x102 0x103

67 45 23 01
Representing Integers
• int A = 15213; Decimal: 15213
• int B = -15213; Binary: 0011 1011 0110 1101
• long int C = 15213; Hex: 3 B 6 D

Linux/Alpha A Sun A Linux C Alpha C Sun C

6D 00 6D 6D 00
3B 00 3B 3B 00
00 3B 00 00 3B
00 6D 00 00 6D
00
Linux/Alpha B Sun B 00
00
93 FF
00
C4 FF
FF C4
FF 93 Two’s complement representation
(Covered next lecture)
 Representing Pointers
• int B = -15213; Alpha P
• int *P = &B; A0
Alpha Address FC
Hex: 1 F F F F F C A 0 FF
FF
Binary: 0001 1111 1111 1111 1111 1111 1100 1010 0000 01
Sun P 00
Sun Address 00
EF
Hex: E F F F F B 2 C 00
FF
Binary: 1110 1111 1111 1111 1111 1011 0010 Linux P
FB 1100
2C Linux Address D4
F8
Hex: B F F F F 8 D 4
Binary: 1011 1111 1111 1111 1111 1000 1101 FF
0100 BF
Different compilers & machines assign different locations to objects
Representing Floats
• Float F = 15213.0;
Linux/Alpha F Sun F
00 46
B4 6D
6D B4
46 00

IEEE Single Precision Floating Point Representation

Hex: 4 6 6 D B 4 0 0
Binary: 0100 0110 0110 1101 1011 0100 0000
0000
15213: 1110 1101 1011 01

Not same as integer representation, but consistent across machines

Can see some relation to integer representation, but not obvious
 Representing Strings
• Strings in C • char S[6] = "15213";
—Represented by array of characters
—Each character encoded in ASCII format
– Standard 7-bit encoding of character set
– Character “0” has code 0x30
+ Digit i has code 0x30+i
Linux/Alpha S Sun S
—String should be null-terminated
31 31
– Final character = 0 35 35
• Compatibility 32 32
31 31
—Byte ordering is not an issue 33 33
– Data are single byte quantities 00 00
—Text files generally platform independent
– Except for different conventions of line termination character(s)!
Example of C Data Structure
 Common file formats and their endian order are as
follows:
• Adobe Photoshop -- Big Endian
• BMP (Windows and OS/2 Bitmaps) -- Little Endian
• DXF (AutoCad) -- Variable
• GIF -- Little Endian
• IMG (GEM Raster) -- Big Endian
• JPEG -- Big Endian
• FLI (Autodesk Animator) -- Little Endian
• MacPaint -- Big Endian
• PCX (PC Paintbrush) -- Little Endian
• PostScript -- Not Applicable (text!)
• POV (Persistence of Vision ray-tracer) -- Not Applicable (text!)
• QTM (Quicktime Movies) -- Little Endian (on a Mac!)
• Microsoft RIFF (.WAV & .AVI) -- Both
• Microsoft RTF (Rich Text Format) -- Little Endian
• SGI (Silicon Graphics) -- Big Endian
• Sun Raster -- Big Endian
• TGA (Targa) -- Little Endian
• TIFF -- Both, Endian identifier encoded into file
• WPG (WordPerfect Graphics Metafile) -- Big Endian (on a PC!)
• XWD (X Window Dump) -- Both, Endian identifier encoded into file