331 Week 4.1Spring 2006 14:332:331 Computer Architecture and Assembly Language Spring 06 Week 4: Addressing Mode, Assembler, Linker [Adapted from Dave.

331 Week 4.1 Spring 2006

14:332:331Computer Architecture and Assembly Language

Spring 06

Week 4: Addressing Mode, Assembler, Linker

[Adapted from Dave Patterson’s UCB CS152 slides and

Mary Jane Irwin’s PSU CSE331 slides]


MIPS (SPIM) Assembler Syntax

Comments begin with #. Everything from # to the end of the line is ignored.

Identifiers are a sequence of alphanumeric characters, underbars (_), and dots (.) that do not begin with a number.

Labels are declared by putting them at the beginning of a line followed by a colon.

.dataitem: .word 1

.text

.global main # Must be globalmain: lw $t0, item


SPIM supported MIPS directive .align n align the next datum on a 2n byte

boundary.

.ascii str store the string str in mem, but do not null-terminate it.

.asciiz str store the string str in mem, but null-terminate it.

.byte b1, …, bn store the n values in successive bytes of memory.

.data <addr> subsequent items are stored in the data segment. If the optional argument addr is present, subsequent items are stored starting at address addr.

.double d1,…,dn store the n floating-point double precision numbers in successive memory locations.


SPIM supported MIPS directive (cont’d) .extern sym size Declare that the datum stored at sym

is size bytes large and is a global label.

.float f1,…,fn store the n floating-point single precision numbers in successive memory locations.

.global sym Declare that label sym is global and can be referenced from other files.

.half h1, …, hn store the n 16-bit quantities in successive memory halfwords.

.kdata <addr> subsequent items are stored in the kernel data segment. If the optional argument addr is present, subsequent items are stored starting at addr.

.ktext <addr> Subsequent items are put in the kernel text segment. If the optional argumentaddr is present, subsequent items are stored starting at addr.


SPIM supported MIPS directive (cont’d) .set no at It prevents SPIM from complaining

about subsequent instructions that use register $at.

.set no at It prevents SPIM from complaining about subsequent instructions that use

register $at.

.space n Allocate n bytes of space in the current segment (which must be data segment in SPIM)

.text <addr> Subsequent items are put in the text segment. If the optional argument addr is present, subsequent items are stored starting at addr.

.word w1,…,wn store the n 32-bit quantities in successive memory words.


Branching Far Away

What if the branch destination is further away than can be captured in 16 bits?

beq $s0, $s1, L1


Small constants are used quite frequently (often 50% of operands)e.g., A = A + 5;

B = B + 1;C = C - 18;

Solutions? Why not? put “typical constants” in memory and load them create hard-wired registers (like $zero) for constants

Dealing with Constants

Allow for MIPS instructions like

addi $sp, $sp, 4slti $t0, $t1, 10andi $t0, $t0, 6ori $t0, $t0, 4

How do we make this work?


MIPS immediate instructions:

addi $sp, $sp, 4 #$sp = $sp + 4

slti $t0, $s2, 15 #$t0 = 1 if $s2<15

Machine format:

The constant is kept inside the instruction itself! I format – Immediate format Limits immediate values to the range +215–1 to -215

Immediate Operands

op rs rt 16 bit immediate I format

8 29 29 4

10 18 8 15


We'd also like to be able to load a 32 bit constant into a register

Must use two instructions, new "load upper immediate" instruction

lui $t0, 1010101010101010

Then must get the lower order bits right, i.e., ori $t0, $t0, 1010101010101010

How About Larger Constants?

16 0 8 1010101010101010

1010101010101010

0000000000000000 1010101010101010

0000000000000000


MIPS Addressing Modes Register addressing – operand is in a register

Base (displacement) addressing – operand is at the memory location whose address is the sum of a register and a 16-bit constant contained within the instruction

Immediate addressing – operand is a 16-bit constant contained within the instruction

PC-relative addressing –instruction address is the sum of the PC and a 16-bit constant contained within the instruction

Pseudo-direct addressing – instruction address is the 26-bit constant contained within the instruction concatenated with the upper 4 bits of the PC


Addressing Modes Illustrated1. Register addressing

op rs rt rd funct Register

word operand

op rs rt offset

2. Base addressing

base register

Memory

word or byte operand

3. Immediate addressing

op rs rt operand

4. PC-relative addressing

op rs rt offset

Program Counter (PC)

Memory

branch destination instruction

5. Pseudo-direct addressing

op jump address

Program Counter (PC)

Memory

jump destination instruction||


Design Principles

Simplicity favors regularity fixed size instructions – 32-bits small number of instruction formats

Smaller is faster limited instruction set limited number of registers in register file limited number of addressing modes

Good design demands good compromises three instruction formats

Make the common case fast arithmetic operands from the register file (load-store

machine) allow instructions to contain immediate operands


Review: MIPS ISA, so farCategory Instr Op Code Example Meaning

Arithmetic

(R & I format)

add 0 and 32 add $s1, $s2, $s3 $s1 = $s2 + $s3

subtract 0 and 34 sub $s1, $s2, $s3 $s1 = $s2 - $s3

add immediate 8 addi $s1, $s2, 6 $s1 = $s2 + 6

or immediate 13 ori $s1, $s2, 6 $s1 = $s2 v 6

Data Transfer

(I format)

load word 35 lw $s1, 24($s2) $s1 = Memory($s2+24)

store word 43 sw $s1, 24($s2) Memory($s2+24) = $s1

load byte 32 lb $s1, 25($s2) $s1 = Memory($s2+25)

store byte 40 sb $s1, 25($s2) Memory($s2+25) = $s1

load upper imm 15 lui $s1, 6 $s1 = 6 * 216

Cond. Branch (I & R format)

br on equal 4 beq $s1, $s2, L if ($s1==$s2) go to L

br on not equal 5 bne $s1, $s2, L if ($s1 !=$s2) go to L

set on less than 0 and 42 slt $s1, $s2, $s3 if ($s2<$s3) $s1=1 else $s1=0

set on less than immediate

10 slti $s1, $s2, 6 if ($s2<6) $s1=1 else $s1=0

Uncond. Jump (J & R format)

jump 2 j 2500 go to 10000

jump register 0 and 8 jr $t1 go to $t1

jump and link 3 jal 2500 go to 10000; $ra=PC+4


The Code Translation Hierarchy

C program

compiler

assembly code

assembler

object code library routines

executable

linker

loader

memory

machine code


Compiler

Transforms the C program into an assembly language program

Advantages of high-level languages many fewer lines of code easier to understand and debug

Today’s optimizing compilers can produce assembly code nearly as good as an assembly language programming expert and often better for large programs

good – smaller code size, faster execution


Assembler Transforms symbolic assembler code into object (machine)

code

Advantages of assembly language Programmer has more control compared to higher level

language much easier than remembering instruction binary codes can use labels for addresses – and let the assembler do the

arithmetic can use pseudo-instructions

- e.g., “move $t0, $t1” exists only in assembler (would be implemented using “add $t0,$t1,$zero”)

However, must remember that machine language is the underlying reality

e.g., destination is no longer specified first

And, when considering performance, you should count real instructions executed, not code size


Other Tasks of the Assembler Determines binary addresses corresponding to all labels

keeps track of labels used in branches and data transfer instructions in a symbol table

- pairs of symbols and addresses

Converts pseudo-instructions to legal assembly code register $at is reserved for the assembler to do this

Converts branches to far away locations into a branch followed by a jump

Converts instructions with large immediates into a load upper immediate followed by an or immediate

Converts numbers specified in decimal and hexidecimal into their binary equivalents

Converts characters into their ASCII equivalents


Typical Object File Pieces Object file header: size and position of following pieces

Text module: assembled object (machine) code

Data module: data accompanying the code static data - allocated throughout the program dynamic data - grows and shrinks as needed by the program

Relocation information: identifies instructions (data) that use (are located at) absolute addresses – those that are not relative to a register (e.g., jump destination addr) – when the code and data is loaded into memory

Symbol table: remaining undefined labels (e.g., external references)

Debugging information

Object fileheader

text segment

data segment

relocation information

symbol table

debugging information


MIPS (spim) Memory AllocationMemory

230

words

0000 0000

f f f f f f f c

YourCode

Reserved

Static data

Mem Map I/O

0040 0000

1000 00001000 8000 ( 1004 0000)

7f f e f f fcStack

Dynamic data

$sp

$gp

PC

Kernel Code & Data 8000 0080


Process that produces an executable file

Source file

Source file

Source file

compiler + assembler



object file

object file

object file

linker

programlibrary

Executable file


Linker Takes all of the independently assembled code segments and

“stitches” (links) them together Much faster to patch code and recompile and reassemble that

patched routine, than it is to recompile and reassemble the entire program

Decides on memory allocation pattern for the code and data modules of each segment

remember, segments were assembled in isolation so each assumes its code’s starting location is 0x0040 0000 and its static data starting location is 0x1000 0000

Absolute addresses must be relocated to reflect the new starting location of each code and data module

Uses the symbol table information to resolve all remaining undefined labels

branches, jumps, and data addresses to external segments


Loader

main:jal ???...jal ???

call, sub call, printf

instructions

Relocationrecords

printf:...

C library

sub:...

object file

object file

linker

main:jal sub...jal printf

printf:...

sub:...

executable file


Loader Loads (copies) the executable code now stored on disk into

memory at the starting address specified by the operating system

Initializes the machine registers and sets the stack pointer to the first free location (0x7ffe fffc)

Copies the parameters (if any) to the main routine onto the stack

Jumps to a start-up routine (at PC addr 0x0040 0000 on xspim) that copies the parameters into the argument registers and then calls the main routine of the program with a jal main

331 Week 4.1Spring 2006 14:332:331 Computer Architecture and Assembly Language Spring 06 Week 4: Addressing Mode, Assembler, Linker [Adapted from Dave.

Documents

addr ktext subsequent

subsequent instructions

space n

optional argument addr

n values

item slide

n bytes of space

mips instructions