Transcript oldchapter2part3

CS/COE0447
Computer Organization & Assembly
Language
Chapter 2 Part 3
1
Topics
•
•
•
•
Register Usage Conventions
Stack and Frame Pointers
Procedure Calls
Creating executables
– Assembler, linker, loader
– Compilers versus interpreters
• What does the assembler do for you?
2
Register Usage Convention
NAME
REG. NUMBER
USAGE
$zero
0
zero
$at
1
reserved for assembler usage
$v0~$v1
2~3
values for results and expression eval.
$a0~$a3
4~7
arguments
$t0~$t7
8~15
temporaries
$s0~$s7
16~23
temporaries, saved
$t8~$t9
24~25
more temporaries
$k0~$k1
26~27
reserved for OS kernel
$gp
28
global pointer
$sp
29
stack pointer
$fp
30
frame pointer
$ra
31
return address
3
Stack and Frame Pointers
•
Stack pointer ($sp)
–
–
–
–
•
Procedure frame
–
–
•
Keeps the address to the top of the stack
$29 is reserved for this purpose
Stack grows from high address to low
Typical stack operations are push/pop
Contains saved registers and local variables
“Activation record”
Frame pointer ($fp)
–
–
–
–
Points to the first word of a frame
Offers a stable reference pointer
$30 is reserved for this
Some compilers don’t use $fp
4
Procedure Calls
• Argument passing
– First 4 arguments are passed through $a0~$a3
– More arguments are passed through stack
• Result passing
– First 2 results are passed through $v0~$v1
– More results can be passed through stack
• Stack manipulations can be tricky and error-prone
• A programming assignment will involve the stack
5
“C Program” Down to “Numbers”
swap:
muli
add
lw
lw
sw
sw
jr
$2, $5, 4
$2, $4, $2
$15, 0($2)
$16, 4($2)
$16, 0($2)
$15, 4($2)
$31
void swap(int v[], int k)
{
int temp;
temp = v[k];
v[k] = v[k+1];
v[k+1] = temp;
}
00000000101000010…
00000000000110000…
10001100011000100…
10001100111100100…
10101100111100100…
10101100011000100…
00000011111000000…
6
To Produce an Executable
source file
.asm/.s
assembler
object file
.obj/.o
source file
.asm/.s
assembler
object file
.obj/.o
source file
.asm/.s
assembler
object file
.obj/.o
linker
executable
.exe
library
.lib/.a
7
Linker
8
An Object File
• Header
– Size and position of other pieces of the file
• Text segment
– Machine codes
• Data segment
– Binary representation of the data in the source
• Relocation information
– Identifies instructions and data words that depend on absolute addresses
• Symbol table
– Keeps addresses of global labels
– Lists unresolved references
• Debugging information
– Contains a concise description of the way in which the program was compiled
9
Interpreter vs. Compiler
Interpreter
Compiler
Concept
Line-by-line translation and execution
Whole program translation and native
execution
Example
Java, BASIC, …
C, Fortran, …
+
Interactive
Portable (e.g., Java Virtual Machine)
High performance
–
Low performance
Binary not portable to other machines or
generations
10
An Assembler
•
Expands macros
–
–
•
Macro is a sequence of operations conveniently defined by a user
A single macro can expand to many instructions
Determines addresses and translates source into binary numbers
–
–
–
Record in “symbol table” addresses of labels
Resolve branch targets and complete branch instructions’ encoding
Record instructions that need be fixed after linkage
•
Packs everything in an object file
•
“Two-pass assembler”
–
To handle forward references
11
Assembler Directives
• Guides the assembler to properly handle following
codes with certain considerations
• .text
– Tells assembler that codes follow
• .data
– Tells assembler that data follow
• .align
– Directs aligning the following items
• .global
– Tells to treat the following symbol as global
• .asciiz
– Tells to handle the following as a “string”
12
Macro Example
.data
int_str:
.macro
.asciiz “%d”
.text
print_int($arg)
la $a0, int_str
mov $a1, $arg
jal printf
.end_macro
…
print_int($7)
la $a0, int_str
mov $a1, $7
jal printf
To use macros in MARS, need to run it from the command line
13
High-Level Lang. vs. Assembly
High-level language
Assembly
Example
C, Fortran, Java, …
-
+
High productivity
– Short description & readability
Portability
Low productivity
– Long description & low readability
Not portable
–
Limited optimization capability in certain
cases
With proper knowledge and experiences,
fully optimized codes can be written
14
Branch and Jump Instructions
Review
15
Instruction Format
I
op
rs
rt
16-bit immediate
• beq, bne PC = PC + 4 + BranchAddr
• Without delayed branching (in MARS!!)
– PC = PC + BranchAddr
• BranchAddr = {14{immediate[15]},immediate,2'b0}
• Two issues:
– Assembly  machine code
– Execution of the machine code
16
0x00400024
0x00400028
0x0040002c
0x00400030
bne $t0,$s5,exitloop
addi $s3,$s3,1
j loop
exitloop: add $s6,$s3,$zero
BNE machine code in binary:
000101 01000 10101 0000000000000011
BNE machine code in hex: 15150003
BranchAddr = {14{immediate[15]},immediate,2'b0}
= {00000000000000,0000000000000011,00}
= 0000 0000 0000 00 00 0000 0000 0000 1100
= 0x0000000c
When BNE instruction is executed (condition true):
Next address = PC + BranchAddr
Next address = 00400024 + 0000000c
= 00400030 … address of the exitloop inst!
17
BranchAddr: Why 2’b0 at the end?
• BranchAddr might have been:
{16{immediate[15]},immediate}
• {number,00} = number * 4 (like shifting left by 2)
• Recall: the immediate field of the instruction
contains the number of instructions away the
label is
• Each instruction is 4 bytes, so multiplying by 4
gives you the number of bytes away it is. This is
the number to add to the PC to jump to the label.
18
BranchAddress: Why 2’b0 at the end?
• If immediate instead were the number of bytes
away the label is, then we would be wasting 2
bits
• Since all instruction addresses are multiples of
4, the bottom 2 bits are always 00
• By not including those bits in the immediate field
of the machine code, branch instructions can be
used to jump 4 times further away
19
Nice question for an Exam 
• What would change in the previous example, if delayed
branching were used in MARS?
• The immediate value would be 1 less
• With delayed branching:
– PC = PC + 4 + BranchAddress
– The “4” is due to the fact that the PC has already been incremented to
point to the next instruction
• In EG (slide 17): imm would be 0000000000000010
• PC = PC + 4 + BranchAddress
• BranchAddress = {14{0},0000000000000010,00} =
0x00000008
• PC = 0x00400024 + 4 + 8 = 0x00400030
20
Instruction Format, cont’d
Jump
op
26-bit address
• The address of next instruction is obtained by concatenating with PC
PC = {PC[31:28],address,2’b0}
21
0x00400018
0x0040001c
0x00400020
ELSE:
0x00400024
0x00400028
0x0040002c
bne $s4, $s5, ELSE
add $s3, $s2, $s5
j EXIT
sub $s3, $s2, $s5
addi $s5, $s5, 1
EXIT: addi $s4,$s4,1
j instruction machine code:
Hex: 0810000b Look at execution:
PC = {PC[31:28],address,00}
PC[31:28] = 0000
address = 00 0001 0000 0000 0000 0000 1011
{0000, address, 00} =
0000 00 0001 0000 0000 0000 0000 1011 00 BIN
0
0
4
0
0
0
2
c
HEX
The address EXIT stands for!
22