Upload
aleesha-davidson
View
219
Download
0
Tags:
Embed Size (px)
Citation preview
CDA 3101 Fall 2013
Introduction to Computer Organization
Pointers & Arrays
MIPS Programs
16 September 2013
Overview
• Pointers (addresses) and values
• Argument passing
• Storage lifetime and scope
• Pointer arithmetic
• Pointers and arrays
• Pointers in MIPS
Review: Pointers• Pointer: a variable that contains the address of
another variable– HLL version of machine language memory address
• Why use Pointers?– Sometimes only way to express computation– Often more compact and efficient code
• Why not? – Huge source of bugs in real software, perhaps the
largest single source1) Dangling reference (premature free) 2) Memory leaks (tardy free): can't have long-running
jobs without periodic restart of them
Review: C Pointer Operators• Suppose c has value 100, it is located in memory at
address 0x10000000• Unary operator & gives address: p = &c; gives address of c to p; – p “points to” c (p == 0x10000000) (Referencing)
• Unary operator * gives value that pointer points to– if p = &c => * p == 100 (Dereferencing a pointer)
• Deferencing data transfer in assembler– ... = ... *p ...; load
(get value from location pointed to by p)– *p = ...; store
(put value into location pointed to by p)
Review: Pointer Arithmetic
int x = 1, y = 2; /* x and y are integer variables */
int z[10]; /* an array of 10 ints, z points to start */
int *p; /* p is a pointer to an int */
x = 21; /* assigns x the new value 21 */
z[0] = 2; z[1] = 3 /* assigns 2 to the first, 3 to the next */
p = &z[0]; /* p refers to the first element of z */
p = z; /* same thing; p[ i ] == z[ i ]*/
p = p+1; /* now it points to the next element, z[1] */
p++; /* now it points to the one after that, z[2] */
*p = 4; /* assigns 4 to there, z[2] == 4*/
p = 3; /* bad idea! Absolute address!!! */
p = &x; /* p points to x, *p == 21 */
z = &y illegal!!!!! array name is not a variable
y:
x:
p:
z[0]
z[1]
1
2
2
234
Review: Assembly Code
c is int, has value 100, in memory at address 0x10000000, p in $a0, x in $s0
1.p = &c; /* p gets 0x10000000*/ lui $a0,0x1000 # p = 0x10000000
2. x = *p; /* x gets 100 */ lw $s0, 0($a0) # dereferencing p
3.*p = 200; /* c gets 200 */ addi $t0,$0,200 sw $t0, 0($a0) # dereferencing p
Argument Passing Options• 2 choices
– “Call by Value”: pass a copy of the item to the function/procedure
– “Call by Reference”: pass a pointer to the item to the function/procedure
• Single word variables passed by value• Passing an array? e.g., a[100]
– Pascal (call by value) copies 100 words of a[] onto the stack
– C (call by reference) passes a pointer (1 word) to the array a[] in a register
Lifetime of Storage and Scope
• Automatic (stack allocated)– Typical local variables of a function– Created upon call, released upon return– Scope is the function
• Heap allocated– Created upon malloc, released upon free– Referenced via pointers
• External / static– Exist for entire program
Code
Static
Heap
Stack
Arrays, Pointers, and Functions
• 4 versions of array function that adds two arrays and puts sum in a third array (sumarray)
1. Third array is passed to function
2. Using a local array (on stack) for result and passing a pointer to it
3. Third array is allocated on heap
4. Third array is declared static
• Purpose of example is to show interaction of C statements, pointers, and memory allocation
Version 1 int x[100], y[100], z[100];
sumarray(x, y, z);
• C calling convention means: sumarray(&x[0], &y[0], &z[0]);
• Really passing pointers to arrays addi $a0,$gp,0 # x[0] starts at $gp
addi $a1,$gp,400 # y[0] above x[100]
addi $a2,$gp,800 # z[0] above y[100]
jal sumarray
Version 1: Compiled Codevoid sumarray(int a[], int b[], int c[]) {
int i;
for(i = 0; i < 100; i = i + 1) c[i] = a[i] + b[i];
}
addi $t0,$a0,400 # beyond end of a[]Loop: beq $a0,$t0,Exit
lw $t1, 0($a0) # $t1=a[i]lw $t2, 0($a1) # $t2=b[i]add $t1,$t1,$t2 # $t1=a[i] + b[i]sw $t1, 0($a2) # c[i]=a[i] + b[i] addi $a0,$a0,4 # $a0++addi $a1,$a1,4 # $a1++addi $a2,$a2,4 # $a2++j Loop
Exit: jr $ra
Version 2
int *sumarray(int a[],int b[]) {
int i, c[100];for(i=0;i<100;i=i+1)
c[i] = a[i] + b[i];return c;
}
addi $t0,$a0,400 # beyond end of a[] addi $sp,$sp,-400 # space for c addi $t3,$sp,0 # ptr for c addi $v0,$t3,0 # $v0 = &c[0]Loop: beq $a0,$t0,Exit lw $t1, 0($a0) # $t1=a[i] lw $t2, 0($a1) # $t2=b[i] add $t1,$t1,$t2 # $t1=a[i] + b[i] sw $t1, 0($t3) # c[i]=a[i] + b[i] addi $a0,$a0,4 # $a0++ addi $a1,$a1,4 # $a1++ addi $t3,$t3,4 # $t3++ j LoopExit: addi $sp,$sp, 400 # pop stack jr $ra
c[100]$sp
a[100]B[100]
Version 3
int * sumarray(int a[],int b[]) {int i; int *c;
c = (int *) malloc(100);for(i=0;i<100;i=i+1)
c[i] = a[i] + b[i];return c;
}
Code
Static
Heap
Stack
c[100]
• Not reused unless freed– Can lead to memory leaks– Java, Scheme have garbage
collectors to reclaim free space
Version 3: Compiled Code
addi $t0,$a0,400 # beyond end of a[]addi $sp,$sp,-12 # space for regssw $ra, 0($sp) # save $rasw $a0, 4($sp) # save 1st arg.sw $a1, 8($sp) # save 2nd arg.addi $a0,$zero,400 jal mallocaddi $t3,$v0,0 # ptr for clw $a0, 4($sp) # restore 1st arg.lw $a1, 8($sp) # restore 2nd arg.
Loop: beq $a0,$t0,Exit... (loop as before on prior slide )j Loop
Exit:lw $ra, 0($sp) # restore $raaddi $sp, $sp, 12 # pop stack jr $ra
Version 4int * sumarray(int a[],int b[]) {
int i; static int c[100];
for(i=0;i<100;i=i+1) c[i] = a[i] + b[i];
return c;}
• Compiler allocates once forfunction, space is reused – Will be changed next time sumarray invoked
– Why describe? used in C libraries
Code
Static
Heap
Stack
c[100]
New Topic - MIPS Programs• Data types and addressing included in the ISA
• Compromise between application requirements and hardware implementation
• MIPS data types• 32-bit word• 16-bit half word• 8-bit bytes
• Addressing Modes• Data
• Register• 16-bit signed constants• Base addressing
• Instructions• PC-relative• (Pseudo) direct
Overview of Program Development
C program: foo.c
Compiler (cc)
Assembly program: foo.s
Assembler (as)
Object(mach lang module): foo.o
Linker (ld)
Executable(mach lang pgm): a.out
Loader
Memory
lib.o
Assembler• Reads and use directives• Replace pseudoinstructions
– subu $sp,$sp,32 addiu $sp, $sp, -32– sd $a0, 32($sp) sw $a0, 32($sp)
sw $a1, 36($sp)– mul $t7,$t6,$t5 mult $t6,$t5
mflo $t7– la $a0, 0xAABBCCDDlui $at, 0xAABB
ori $a0, $at, 0xCCDD
• Produce machine language• Create object file (*.o)
Assembler Directives• Directions to assembler that don’t produce machine
instructions.align n Align the next datum on a 2n byte boundary.text Subsequent items put in user text segment.data Subsequent items put in user data segment.globl sym sym can be referenced from other files.asciiz str Store the string str in memory.word w1…wn Store the n 32-bit quantities in successive
memory words
.byte b1..bn Store n 8-bit values in successive bytes of memory
.float f1..fn: Store n floating-point numbers in successive memory words
Absolute Addresses• Which instructions need relocation editing?
j/jal xxxxx
• Loads / stores to variables in static area
lw/sw $gp $x address
• Conditional branchesbeq/bne $rs $rt address
–PC-relative addressing preserved even if code moves
• Jump instructions
• Direct (absolute) references to data (e.g. la)
Producing Machine Language • Simple case
– Arithmetic, logical, shifts, etc.
– All necessary info is within the instruction already.
• Conditional branches (beq, bne)– Once pseudoinstructions are replaced by real ones, we
know by how many instructions for branch span
– PC-relative, easy to handle
• Direct (absolute) addresses– Jumps (j and jal)
– Direct (absolute) references to data
– These can’t be determined yet, so we create two tables
Assembler Tables• Symbol table
– List of “items” in this file that may be used by other files.• Labels: function calling• Data: anything in the .data section; variables which may be accessed
across files
– First Pass: record label-address pairs– Second Pass: produce machine code– Can jump to a later label without first declaring it
• Relocation Table– List of “items” for which this file needs the address.– Any label jumped to: j or jal
• internal• external (including lib files)
– Any piece of data (e.g. la instruction)
Object File Format• Object file header: size and position of the
other pieces of the object file• Text segment: the machine code• Data segment: binary representation of the
data in the source file• Relocation information: identifies lines of
code that need to be “handled”• Symbol table: list of this file’s labels and
data that can be referenced• Debugging information
Linker (Link Editor)
• Combines object (.o) files into an executable file• Enables separate (independent) compilation of files
– Only recompile modified file (module)• Windows NT source is >30 M lines of code! And Growing!
• Edits the “links” in jump and link instructions• Process (input: object files produced by assembler)
– Step 1: put together the text segments from each .o file– Step 2: put together the data segments from each .o file and
concatenate this onto end of text segments– Step 3: resolve references. Go through Relocation Table
and handle each entry (fill in all absolute addresses)
Resolving References• Four types of references (addresses)
– PC-relative (e.g. beq, bne): never relocate– Absolute address (j, jal): always relocate– External reference (jal): always relocate– Data reference (lui and ori): always relocate
• Linker assumes first word of first text segment is at address 0x00000000.
• Linker knows:– Length of each text and data segment– Ordering of text and data segments
• Linker calculates:– Absolute address of each label to be jumped to (internal
or external) and each piece of data being referenced
Loader• Executable file is stored on disk.• Loader’s job: load it into memory and start it running.• In reality, loader is part of the operating system (OS)
1. Reads header to determine size of text and data segments2. Creates new address space for program large enough to
hold text and data segments, along with a stack segment3. Copies instructions and data from executable file memory4. Copies arguments passed to the program onto the stack5. Initializes machine registers, $sp = 1st free stack location6. Jumps to start-up routine that copies program’s arguments
from stack to registers and sets the PC7. If main routine returns, start-up routine terminates program
with the exit system call
Example: C => Asm => Obj => Exe => Run
#include <stdio.h>
int main (int argc, char *argv[]) {
int i;
int sum = 0;
for (i = 0; i <= 100; i = i + 1) sum = sum + i * i;
printf ("The sum from 0 .. 100 is %d\n", sum);
}
Example: C => Asm => Obj => Exe => Run
.text
.align 2
.globl mainmain:subu $sp,$sp,32sw $ra, 20($sp)sd $a0, 32($sp)sw $0, 24($sp)sw $0, 28($sp)
loop:lw $t6, 28($sp)mul $t7, $t6,$t6lw $t8, 24($sp)addu $t9, $t8,$t7sw $t9, 24($sp)
addu $t0, $t6, 1 sw $t0, 28($sp)ble $t0,100, loopla $a0, strlw $a1, 24($sp)jal printfmove $v0, $0lw $ra, 20($sp)addiu $sp,$sp,32jr $ra.data.align 0
str:.asciiz "The sum
from 0 .. 100 is %d\n"
Example: C => Asm => Obj => Exe => Run
00 addiu $29,$29,-32
04 sw$31,20($29)
08 sw $4, 32($29)
0c sw $5, 36($29)
10 sw $0, 24($29)
14 sw $0, 28($29)
18 lw $14,28($29)
1c mult $14,$1420 mflo $1524 lw $24,24($29)
28 addu $25,$24,$15
2c sw $25,24($29)
30 addiu $8,$14, 134 sw $8,28($29)38 slti $1,$8, 101 3c bne $1,$0, loop40 lui $4, hi.str44 ori $4,$4,lo.str 48 lw $5,24($29)4c jal printf50 add $2, $0, $054 lw $31,20($29)
58 addiu $29,$29,325c jr $3160 The
Replace pseudoinstructions; assign addresses (start at 0x00)
Symbol and Relocation Tables• Symbol Table
– Label Addressmain: 0x00000000loop: 0x00000018str: 0x10000430printf: 0x004003b0
• Relocation Information– Address Instr. Type Dependency – 0x00000040 HI16 str– 0x00000044 LO16 str– 0x0000004c jal printf
Example: C => Asm => Obj => Exe => Run
00 addiu $29,$29,-3204 sw $31,20($29)08 sw $4,32($29)0c sw $5,36($29)10 sw $0, 24($29)14 sw $0, 28($29)18 lw $14, 28($29)
1c multu $14, $1420 mflo $1524 lw $24, 24($29)
28 addu $25,$24,$152c sw $25, 24($29)
30 addiu $8,$14, 134 sw $8,28($29)38 slti $1,$8, 101 3c bne $1,$0, -9 40 lui $4, 409644 ori $4,$4,1072 48 lw $5,24($29)4c jal 1048812 50 add $2, $0, $054 lw $31,20($29)
58 addiu $29,$29,325c jr $31
Edit addresses
Example: C => Asm => Obj => Exe => Run0x00400000001001111011110111111111111000000x00400004101011111011111100000000000101000x00400008101011111010010000000000001000000x0040000c101011111010010100000000001001000x00400010101011111010000000000000000110000x00400014101011111010000000000000000111000x00400018100011111010111000000000000111000x0040001c100011111011100000000000000110000x00400020000000011100111000000000000110010x00400024001001011100100000000000000000010x00400028001010010000000100000000011001010x0040002c101011111010100000000000000111000x00400030000000000000000001111000000100100x00400034000000110000111111001000001000010x00400038000101000010000011111111111101110x0040003c101011111011100100000000000110000x00400040001111000000010000010000000000000x00400044100011111010010100000000000110000x00400048000011000001000000000000111011000x0040004c001001001000010000000100001100000x00400050100011111011111100000000000101000x00400054001001111011110100000000001000000x00400058000000111110000000000000000010000x0040005c00000000000000000001000000100001
MIPS Program - Summary• Compiler converts a single HLL file into a
single assembly language file.• Assembler removes pseudos, converts what
it can to machine language, and creates a checklist for the linker (relocation table). This changes each .s file into a .o file.
• Linker combines several .o files and resolves absolute addresses.
• Loader loads executable into memory and begins execution.