where are we now?
DESCRIPTION
9. Compiler. Assembly program: foo.s. Assembler. Object(mach lang module): foo.o. Linker. lib.o. Executable(mach lang pgm): a.out. Loader. Memory. Where Are We Now?. C program: foo.c. Linker. Input: Object Code files (e.g., foo.o,libc.o for MIPS) - PowerPoint PPT PresentationTRANSCRIPT
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!!