CSCI-365Computer Organization

Lecture

Note: Some slides and/or pictures in the following are adapted from: Computer Organization and Design, Patterson & Hennessy, ©2005 Some slides and/or pictures in the following are adapted from: slides ©2008 UCB

9

C program: foo.c

Compiler

Assembly program: foo.s

Assembler

Linker

Executable(mach lang pgm): a.out

Loader

Memory

Object(mach lang module): foo.o

lib.o

Where Are We Now?

• Input: Object Code files (e.g., foo.o,libc.o for MIPS)

• Output: Executable Code (e.g., a.out for MIPS)

• Combines several object (.o) files into a single executable (“linking”)

• Enable Separate Compilation of files

– Changes to one file do not require recompilation of whole program

• Windows NT source is > 40 M lines of code!

– Old name “Link Editor” from editing the “links” in jump and link instructions

Linker

.o file 1text 1

data 1

info 1

.o file 2text 2

data 2

info 2

Linker

a.outRelocated text 1

Relocated text 2

Relocated data 1

Relocated data 2

Linker

• Step 1: Take text segment from each .o file and put them together

• Step 2: Take data segment from each .o file, put them together, and concatenate this onto end of text segments

• Step 3: Resolve References– Go through Relocation Table and handle each entry

– That is, fill in all absolute addresses

Linker

• Linker assumes first word of first text segment is at

address 0x00000000

(More on this later when we study “virtual memory”)

• 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

Resolving References

• To resolve references:– Based on list in each relocation table search for

reference (label) in all “user” symbol tables

– if not found, search library files (for example, for printf)

– once absolute address is determined, fill in the machine code appropriately

• Output of linker: executable file containing text and data (plus header)

Resolving References

Static vs. Dynamically linked libraries

• What we’ve described is the traditional way: “statically-linked” approach

– The library is now part of the executable, so if the library updates we don’t get the fix (have to recompile if we have source)

– It includes the entire library even if not all of it will be used

– Executable is self-contained

• An alternative is dynamically linked libraries (DLL), common on Windows & UNIX platforms

– 1st run overhead for dynamic linker-loader

– Having executable isn’t enough anymore!

C program: foo.c

Compiler

Assembly program: foo.s

Assembler

Linker

Executable(mach lang pgm): a.out

Loader

Memory

Object(mach lang module): foo.o

lib.o

Where Are We Now?

• Input: Executable Code(e.g., a.out for MIPS)

• Output: (program is run)

• Executable files are stored on disk

• When one is run, loader’s job is to load it into memory and start it running

• In reality, loader is the operating system (OS) – loading is one of the OS tasks

Loader

Example: C Asm Obj Exe Run

#include <stdio.h>

int main (int argc, char *argv[]) {

int i, sum = 0;

for (i = 0; i <= 100; i++) sum = sum + i * i;

printf ("The sum from 0 .. 100 is %d\n", sum);

}

prog.c

printf lives in libc

Compilation: MIPS .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, 1sw $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 0str:.asciiz "The sum from 0 .. 100 is %d\n"

Where are7 pseudo-instructions?

Compilation: MIPS .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, 1sw $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 0str:.asciiz "The sum from 0 .. 100 is %d\n"

7 pseudo-instructionsunderlined

Assembly step 1

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, loop40 lui $4, l.str44 ori$4,$4,r.str 48 lw$5,24($29)4c jal printf50 add $2, $0, $054 lw $31,20($29) 58 addiu $29,$29,325c jr $31

•Remove pseudoinstructions, assign addresses

Assembly step 2

• Create relocation table and symbol table

• Symbol Table – Label Address (in module) Typemain: 0x00000000 global textloop: 0x00000018 local textstr: 0x00000000 local data

• Relocation Information

– Address Instr. Type Dependency

0x00000040 lui l.str0x00000044 ori r.str 0x0000004c jal printf

Assembly step 3

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, -10 40 lui $4, l.str44 ori$4,$4,r.str 48 lw $5,24($29)4c jal printf 50 add $2, $0, $054 lw $31,20($29) 58 addiu $29,$29,325c jr $31

•Resolve local PC-relative labels

Assembly step 4

• Generate object (.o) file

– Output binary representation for

• text segment (instructions)

• data segment (data)

• symbol and relocation tables

– Using dummy “placeholders” or “guesses” for

unresolved absolute and external references

Text segment in object file

0x000000001001111011110111111111111000000x000004101011111011111100000000000101000x000008101011111010010000000000001000000x00000c101011111010010100000000001001000x000010101011111010000000000000000110000x000014101011111010000000000000000111000x000018100011111010111000000000000111000x00001c100011111011100000000000000110000x000020000000011100111000000000000110010x000024001001011100100000000000000000010x000028001010010000000100000000011001010x00002c101011111010100000000000000111000x000030000000000000000001111000000100100x000034000000110000111111001000001000010x000038000101000010000011111111111101110x00003c101011111011100100000000000110000x000040001111000000010000000000000000000x000044100011111010010100000000000000000x000048000011000001000000000000111011000x00004c001001000000000000000000000000000x000050100011111011111100000000000101000x000054001001111011110100000000001000000x000058000000111110000000000000000010000x00005c00000000000000000001000000100001

Link step 1: combine prog.o, libc.o

• Merge text/data segments

• Create absolute memory addresses

• Modify & merge symbol and relocation tables

• Symbol Table– Label Address (in module)

main: 0x00000000loop: 0x00000018str: 0x10000430printf: 0x000003b0

• Relocation Information

– Address Instr. Type Dependency

0x00000040 lui l.str0x00000044 ori r.str 0x0000004c jal printf

Link step 2

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, -10 40 lui $4, 409644 ori $4,$4,1072 48 lw $5,24($29)4c jal 812 50 add $2, $0, $054 lw $31,20($29) 58 addiu $29,$29,325c jr $31

•Edit Addresses in relocation table (in binary)

Link step 3

• Output executable of merged modules

– Single text (instruction) segment

– Single data segment

– Header detailing size of each segment

• Note

– The preceding example was a much simplified

version of how ELF and other standard formats work,

meant only to demonstrate the basic principles

Decimal Numbers: Base 10

Digits: 0, 1, 2, 3, 4, 5, 6, 7, 8, 9

Example:

3271 =

(3x103) + (2x102) + (7x101) + (1x100)

• Number Base B B symbols per digit:

– Base 10 (Decimal): 0, 1, 2, 3, 4, 5, 6, 7, 8, 9

– Base 2 (Binary): 0, 1

• Number representation: – d31d30 ... d1d0 is a 32 digit number

– value = d31 B31 + d30 B30 + ... + d1 B1 + d0 B0

• Binary: 0,1 (in binary digits called “bits”)

– 0b11010 = 124 + 123 + 022 + 121 + 020 = 16 + 8 + 2= 26

– Here 5 digit binary # turns into a 2 digit decimal #

– Can we find a base that converts to binary easily?

#s often written0b…

Numbers: positional notation

• Hexadecimal:

0, 1, 2, 3, 4, 5, 6, 7, 8, 9, A, B, C, D, E, F

– Normal digits + 6 more from the alphabet

– In C, written as 0x… (e.g., 0xFAB5)

• Conversion: BinaryHex

– 1 hex digit represents 16 decimal values

– 4 binary digits represent 16 decimal values

1 hex digit replaces 4 binary digits

• Example:

– 1010 1100 0011 (binary) = 0x_____ ?

Hexadecimal Numbers: Base 16

Examples:

1010 1100 0011 (binary)

= 0xAC3

10111 (binary)

= 0001 0111 (binary)

= 0x17

0x3F9

= 11 1111 1001 (binary)

How do we convert between hex and

Decimal?

00 0 0000

01 1 0001

02 2 0010

03 3 0011

04 4 0100

05 5 0101

06 6 0110

07 7 0111

08 8 1000

09 9 1001

10 A 1010

11 B 1011

12 C 1100

13 D 1101

14 E 1110

15 F 1111MEMORIZE!

Decimal vs. Hexadecimal vs. Binary

What to do with representations of

numbers?• Just what we do with numbers!

– Add them– Subtract them– Multiply them– Divide them– Compare them

• Example: 10 + 7 = 17– …so simple to add in binary that we can build

circuits to do it!– subtraction just as you would in decimal– Comparison: How do you tell if X > Y ?

1 0 1 0

+ 0 1 1 1

-------------------------

1 0 0 0 1

11

• Characters?– 26 letters 5 bits (25 = 32)– upper/lower case + punctuation

7 bits (in 8) (“ASCII”)– standard code to cover all the world’s languages 8,16,32

bits (“Unicode”)www.unicode.com

• Logical values?– 0 False, 1 True

• colors ? Ex:• locations / addresses? commands?• MEMORIZE: N bits at most 2N things

Red (00) Green (01) Blue (11)

BIG IDEA: Bits can represent anything!!