L06

30/01/2020

CS104: Computer Organization

Lecture 04, 30th January, 2020
Dip Sankar Banerjee
Computer Organization (IS F242)
LectureManojit Ghose
1 : Introductory Thoughts

Dip Sankar Banerjee

dsb@hyderabad.bits-pilani.ac.in
Department
Indian Institute of CS &Technology,
of Information IS Guwahati
Jan-Apr 2020
 L06
30/01/2020

Review
• Pointers and arrays are virtually same
• C knows how to increment pointers
• C is an efficient language, with little protection
– Array bounds not checked
– Variables not automatically initialized
• Use handles to change pointers
• Dynamically allocated heap memory must be manually
deallocated in C.
– Use malloc() and free() to allocate and deallocate memory
from heap.
• (Beware) The cost of efficiency is more overhead for the
programmer.
– “C gives you a lot of extra rope but be careful not to hang yourself
with it!”
 L06
30/01/2020

Assembly Language
• Basic job of a CPU: execute lots of
instructions.
• Instructions are the primitive operations
that the CPU may execute.
• Different CPUs implement different sets of
instructions. The set of instructions a
particular CPU implements is an Instruction
Set Architecture (ISA).
– Examples: Intel 80x86 (Pentium 4),
IBM/Motorola PowerPC (old Macintosh), MIPS,
Intel IA64, ...
 L06
30/01/2020

Instruction Set Architectures

• Early trend was to add more and more
instructions to new CPUs to do elaborate
operations
– VAX architecture had an instruction to multiply
polynomials!
• RISC philosophy (Cocke IBM, Patterson,
Hennessy, 1980s) –
Reduced Instruction Set Computing
– Keep the instruction set small and simple, makes it easier
to build fast hardware.
– Let software do complicated operations by composing
simpler ones.
 L06
30/01/2020

MIPS Architecture
• MIPS – semiconductor company that built one of the
first commercial RISC architectures
• We will study the MIPS architecture in some detail in
this class
• Why MIPS instead of Intel 80x86?
– MIPS is simple, elegant. Don’t want to get bogged
down in gritty details.
– MIPS widely used in embedded apps, x86 little
used in embedded, and more embedded
computers than PCs
 L06
30/01/2020

Assembly Variables: Registers (1/4)

• Unlike HLL like C or Java, assembly cannot
use variables
– Why not? Keep Hardware Simple
• Assembly Operands are registers
– limited number of special locations built
directly into the hardware
– operations can only be performed on these!
• Benefit: Since registers are directly in
hardware, they are very fast
(faster than 1 billionth of a second)
 L06
30/01/2020

Assembly Variables: Registers (2/4)

• Drawback: Since registers are in hardware,
there are a predetermined number of them
– Solution: MIPS code must be very carefully put
together to efficiently use registers
• 32 registers in MIPS
– Why 32? Smaller is faster
• Each MIPS register is 32 bits wide
– Groups of 32 bits called a word in MIPS
 L06
30/01/2020

Assembly Variables: Registers (3/4)

• Registers are numbered from 0 to 31
• Each register can be referred to by number
or name
• Number references:
$0, $1, $2, … $30, $31
 L06
30/01/2020

Assembly Variables: Registers (4/4)

• By convention, each register also has a
name to make it easier to code
• For now:
$16 - $23  $s0 - $s7
(correspond to C variables)
$8 - $15  $t0 - $t7
(correspond to temporary variables)
Later will explain other 16 register names
• In general, use names to make your code
more readable
 L06
30/01/2020

MIPS Registers
 L06
30/01/2020

C, Java variables vs. registers

• In C (and most High Level Languages)
variables declared first and given a type
– Example:
int fahr, celsius;
char a, b, c, d, e;
• Each variable can ONLY represent a value of
the type it was declared as (cannot mix and
match int and char variables).
• In Assembly Language, the registers have no
type; operation determines how register
contents are treated
 L06
30/01/2020

Comments in Assembly
• Another way to make your code more
readable: comments!
• Hash (#) is used for MIPS comments
– anything from hash mark to end of line is a
comment and will be ignored
– This is just like the C99 //
• Note: Different from C.
– C comments have format
/* comment */
so they can span many lines
 L06
30/01/2020

Assembly Instructions
• In assembly language, each statement
(called an Instruction), executes exactly one
of a short list of simple commands
• Unlike in C (and most other High Level
Languages), each line of assembly code
contains at most 1 instruction
• Instructions are related to operations (=, +, -
, *, /) in C or Java
 L06
30/01/2020

MIPS Addition and Subtraction

• Syntax of Instructions:
1 2,3,4
where:
1) operation by name
2) operand getting result (“destination”)
3) 1st operand for operation (“source1”)
4) 2nd operand for operation (“source2”)
• Syntax is rigid:
– 1 operator, 3 operands
– Why? Keep Hardware simple via regularity
 L06
30/01/2020

Addition and Subtraction of Integers

• Addition in Assembly
– Example: add $s0,$s1,$s2 (in MIPS)
Equivalent to:a = b + c (in C)
where MIPS registers $s0,$s1,$s2 are
associated with C variables a, b, c
• Subtraction in Assembly
– Example: sub $s3,$s4,$s5 (in MIPS)
Equivalent to:d = e - f (in C)
where MIPS registers $s3,$s4,$s5 are
associated with C variables d, e, f
 L06
30/01/2020

Addition and Subtraction of Integers

• How do the following C statement?
a = b + c + d - e;
• Break into multiple instructions
add $t0, $s1, $s2 # temp = b + c
add $t0, $t0, $s3 # temp = temp + d
sub $s0, $t0, $s4 # a = temp - e
• Notice: A single line of C may break up into
several lines of MIPS.
• Notice: Everything after the hash mark on
each line is ignored (comments)
 L06
30/01/2020

Addition and Subtraction of Integers

• How do we do this?
f = (g + h) - (i + j);
• Use intermediate temporary register
add $t0,$s1,$s2# temp = g + h
add $t1,$s3,$s4# temp = i + j
sub $s0,$t0,$t1# f=(g+h)-(i+j)
 L06
30/01/2020

Register Zero
• One particular immediate, the number zero
(0), appears very often in code.
• So we define register zero ($0 or $zero)
to always have the value 0; eg
add $s0,$s1,$zero (in MIPS)
f = g (in C)
where MIPS registers $s0,$s1 are associated
with C variables f, g
• defined in hardware, so an instruction
add $zero,$zero,$s0
will not do anything!
 L06
30/01/2020

Immediates
• Immediates are numerical constants.
• They appear often in code, so there are
special instructions for them.
• Add Immediate:
addi $s0,$s1,10 (in MIPS)
f = g + 10 (in C)
where MIPS registers $s0,$s1 are associated
with C variables f, g
• Syntax similar to add instruction, except
that last argument is a number instead of a
register.
 L06
30/01/2020

Immediates
• There is no Subtract Immediate in MIPS:
Why?
• Limit types of operations that can be done
to absolute minimum
– if an operation can be decomposed into a
simpler operation, don’t include it
– addi …, -X = subi …, X => so no subi
• addi $s0,$s1,-10 (in MIPS)
f = g - 10 (in C)
where MIPS registers $s0,$s1 are associated
with C variables f, g
 L06
30/01/2020

MIPS Instructions
 Arithmetic
 add, sub, mult, div
 Logical
 and, or, ssl (shift left logical), srl (shift right
logical)
 Data transfer
 lw (load word), sw (store word)
 lui (load unsigned immediate constant)
 Branches
 Conditional: beq, bne, slt
 Unconditional: j (jump), jr (jump register), jal
 L06
30/01/2020

MIPS Design Principles

 Simple (rigid) instructions
– DP1: Simplicity favors regularity
add a, b, c # a = b + c;
Exactly 3 operands (registers) comment

# a = b + c + d + e;
add a, b, c Format: <opcode> <output> <inp1>
<inp2>
add a, a, d
add a, a, e
 These instructions are symbolic representations of what
MIPS actually understands
 L06
30/01/2020

DP1 Example
Compiling a C assignment statement into MIPS
f = (g + h) – (i + j);
add t0, g, h # temporary variable t0 contains g+h
add t1, i, j # temporary variable t1 contains i+j
sub f, t0, t1 # f gets the final result

In MIPS, these are

register names
 L06
30/01/2020

Operands
 Operands can not be any variable (as in
C)
 KISS principle – avoid CISC pitfalls
 Registers
 Limited number (32 32-bit registers in MIPS)
•DP2: Smaller is faster
 Naming: numbers or names
$8 - $15 => $t0 - $t7 (correspond to temporary
variables)
$16 - $22 => $s0 - $s8 (correspond to C variables)
Names make your code more readable
 L06
30/01/2020

DP2 Example
 L06
30/01/2020

Load and Store Instruction

• Load and store are instructions to access memory.
• Example: h->$s2, base addr(A) -> $s3
C code : A[12] = h + A[8]
MIPS code : lw $t0,32($s3)
add $t0,$s2,$t0
sw $t0,48($s3)
• lw is to load a word i.e to move a word from memory to
register.
• sw is to store a word i.e to move a word from register to
memory.
 L06
30/01/2020

“And in Conclusion…”
• In MIPS Assembly Language:
– Registers replace C variables
– One Instruction (simple operation) per line
– Simpler is Better
– Smaller is Faster
• New Instructions:
add, addi, sub
• New Registers:
C Variables: $s0 - $s7
Temporary Variables: $t0 - $t9
Zero: $zero