EE 344
Digital Computer Systems
Lecture 5:
Assembly Language, an Overview
Where are we?
Very close to the hardware
Link between HLL, ISA, and
microarchitecture
One HLL instruction may be implemented with
several assembly language instructions
Symbolic presentation of the instruction set
architecture (ISA) level
Programs written with different HLL can be
transformed to the same assembly language
Not Easy!
Limited storage resources (memory and
registers)
No notion of types, it is the programmer
responsibility to use the correct instructions
Only go to control instructions
Amount of work done by an instruction is
smaller than a HLL instructions
Much longer to debug and much harder to
maintain
Difficult to think at that low level
Not portable
Why bother, then?
Performance (speed and cost)
Much smaller than HLL
Much faster than HLL
Complete access to the hardware
features
Device drivers
Interrupts
Some real-time embedded systems
etc...
The view/model
(registers and memory)
The assembly programmer
sees memory and registers
Assembly-Language
Instruction types
Data Types
the key difference between mediocre
and excellent programmers is whether
or not they know assembly language.
The Memory
Large number of locations
Each location has a fixed size width
(usually the width is 1 byte)
Collection of all locations is called
memory address space
In assembly we use labels
Memory address space is used to store
instructions and data
Typical Memory Organization
Addresses
0x00000000
0x00000001
.
.
.
Memory Address Space
Hold the instructions
Usually read-only from
Programmer point of view
OS can still write to it
Text
Data
To store the data (local
and global) during run-time
Direction of growth
At run-time
Stack
To store data required during
Subroutine activation, including
Local variables
Register Model FAQ
Where are the registers?
Inside the processor chip
What is their function
Holding data needed frequently
How many registers do we have?
Usually few
Why?
Decoder used in selection is much smaller than the one used
for memory
Limited space on-chip
Few bits to specify a register
Technology
Commonly Used Registers
PC: program counter
ACC: Accumulator
SP: Stack Pointer
Link register
General purpose registers (GPRs)
Flag register
N---negative result
Z--- zero result
V--- overflow
C--- carry
other
What about Data Types?
There is no notion of variables
Type is specified based on the
instruction used
Instructions deal with few data types:
Signed/unsigned integers
Floating point
Decimal (BCD)
characters
Instructions
Each assembly-level architecture has its
own group of instructions -> instruction
set
Instructions can be grouped into four
categories:
Data Transfer
Data Manipulation
Program Sequencing and Control
Trap/system call
Instructions: Data Transfer
Instructions: Data Manipulation
Instructions: Program Sequencing
and Control
Welcome to MIPS Assembly
Language
Why MIPS?
Patterson and Hennessy use MIPS assembly language. Given the
overwhelming acceptance of their textbook as the standard, this
is already a strong argument.
RISC architectures actually are dominant.
It's best to teach a subject by going from the simple to the
complex. The MIPS R2000 instruction set architecture is
probably the simplest in existence for a real processor with a
significant market. In contrast, the Intel architecture, is
extremely complex.
Electrical and software engineers do, in fact, need to write
assembly-language programs for embedded processors. (e.g. HP
4000 laser printer, Nintendo, Sony playstation, etc.)
Other system integrators, such as router and telephone-switch
manufacturers, make use of embedded processors.
In all cases, these RISC architectures are extremely similar to
the MIPS R2000 architecture that Hennessy and Patterson use
throughout their text. A student who has learned the MIPS
R2000 instruction set is in a good position to write programs for
any embedded RISC processor.
You really should do
http://www.cs.unibo.it/~solmi/teaching/arch_20022003/AssemblyLanguageProgDoc.pdf
(MIPS assembly Language Programmers Guide -> download it!)
http://logos.cs.uic.edu/366/notes/MIPS%20Quick%20Tutorial.htm
(A quick start on MIPS assembly -> look at it!)
Get Some books:
MIPS Assembly Language Programming
by Robert Britton. Published by Prentice Hall.
See MIPS Run
by Dominic Sweetman. Publisher: Morgan Kaufmann
Computer Structure
Keyboard,
Mouse
Computer
Processor
Control
(brain)
Datapath
Memory
Devices
(where
programs,
data
live when
running)
Input
Output
Disk
(where
programs,
data
live when
not running)
Display,
Printer
MIPS arithmetic
All instructions have 3 operands and order is fixed (destination
first)
Example:
C code:
a=b+c
MIPS code:
add a, b, c
The natural number of operands for an operation like addition is
threerequiring every instruction to have exactly three operands,
no more and no less, conforms to the philosophy of keeping the
hardware simple
MIPS arithmetic
Design Principle: simplicity favors regularity.
Of course this complicates some things...
(what are these things?)
C code: a = b + c + d;
MIPS code:
add a, b, c
add a, a, d
Operands must be registers,
Only 32 registers provided
Each register contains 32 bits
Design Principle: smaller is faster.
What about programs with lots of variables?
10
11
12
13
14
Meaning:
$t0 = Memory[$s3+24]
Let $s3 = 1001 0100
15
16
Memory Organization
Viewed as a large, single-dimension array, with an address.
A memory address is an index into the array
"Byte addressing" means that the index points to a byte of
memory.
0
8 bits of data
8 bits of data
8 bits of data
8 bits of data
8 bits of data
8 bits of data
8 bits of data
...
17
Memory Organization
Bytes
are nice, but most data items use larger
"words"
For MIPS, a word is 32 bits or 4 bytes.
Registers hold 32 bits of data
232 bytes with byte addresses from 0 to 232-1
230 words with byte addresses 0, 4, 8, ... 232-4
Instructions
Load and store instructions
Example:
C code:
A[12] = h + A[8];
MIPS code:
lw $t0, 32($s3)
add $t0, $s2, $t0
sw $t0, 48($s3)
Can refer to registers by name (e.g., $s2, $t2) instead of
number
Store word has destination last
Remember arithmetic operands are registers, not memory!
Cant write:
add 48($s3), $s2, 32($s3)
Byte Addressing: 4x8=32
$s3 is called Base Register
Data Transfer Instruction: A[8] is offset
18
Summary
MIPS
loading words but addressing bytes
arithmetic on registers only
Instruction
Meaning
add $s1, $s2, $s3
sub $s1, $s2, $s3
lw $s1, 100($s2)
sw $s1, 100($s2)
$s1 = $s2 + $s3
$s1 = $s2 $s3
$s1 = Memory[$s2+100]
Memory[$s2+100] = $s1
19
ori = OR immediate
20
21
22
Examples of sll &srl
Sll $t2, $s0, 2
Multiply by 4
.0010
00100 Shift left once (* by 2)
001000 Shift left twice(* by 4)
srl $t2, $s0, 2
Divide by 4
001
0001 Shift right once (div by 2)
00001Shift right twice(div by 4)
23
24
MIPS Instruction Classes
25
26
27
28
(Section 2.8)
29
See you next time.
30
