14:332:331 Computer 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] 331 Week 4.1 Spring 2006 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. item: main: 331 Week 4.2 .data .word 1 .text .global main # Must be global lw $t0, item Spring 2006 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 nullterminate it. .byte b1, …, bn store the n values in successive bytes of memory. .data <addr> .double d1,…,dn store the n floating-point double precision numbers in successive memory locations. 331 Week 4.3 subsequent items are stored in the data segment. If the optional argument addr is present, subsequent items are stored starting at address addr. Spring 2006 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 argument addr is present, subsequent items are stored starting at addr. 331 Week 4.4 Spring 2006 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. 331 Week 4.5 Spring 2006 Branching Far Away What if the branch destination is further away than can be captured in 16 bits? beq 331 Week 4.6 $s0, $s1, L1 Spring 2006 Dealing with Constants Small constants are used quite frequently (often 50% of operands) e.g., Solutions? Why not? put “typical constants” in memory and load them create hard-wired registers (like $zero) for constants Allow for MIPS instructions like addi slti andi ori A = A + 5; B = B + 1; C = C - 18; $sp, $t0, $t0, $t0, $sp, $t1, $t0, $t0, 4 10 6 4 How do we make this work? 331 Week 4.7 Spring 2006 Immediate Operands MIPS immediate instructions: addi $sp, $sp, 4 #$sp = $sp + 4 slti $t0, $s2, 15 #$t0 = 1 if $s2<15 Machine format: op rs rt 16 bit immediate 8 29 29 4 10 18 8 15 I format The constant is kept inside the instruction itself! 331 Week 4.8 I format – Immediate format Limits immediate values to the range +215–1 to -215 Spring 2006 How About Larger Constants? 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 16 0 8 1010101010101010 Then must get the lower order bits right, i.e., ori $t0, $t0, 1010101010101010 331 Week 4.9 1010101010101010 0000000000000000 0000000000000000 1010101010101010 Spring 2006 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 331 Week 4.10 Spring 2006 Addressing Modes Illustrated 1. Register addressing op rs rt rd funct Register word operand 2. Base addressing op rs rt offset Memory word or byte operand base register 3. Immediate addressing op rs rt operand 4. PC-relative addressing op rs rt offset Memory branch destination instruction Program Counter (PC) 5. Pseudo-direct addressing op Memory jump address || jump destination instruction Program Counter (PC) 331 Week 4.11 Spring 2006 Design Principles Simplicity favors regularity Smaller is faster limited instruction set limited number of registers in register file limited number of addressing modes Good design demands good compromises fixed size instructions – 32-bits small number of instruction formats three instruction formats Make the common case fast 331 Week 4.12 arithmetic operands from the register file (load-store machine) allow instructions to contain immediate operands Spring 2006 Review: MIPS ISA, so far Category Instr Op Code Example Meaning Arithmetic add 0 and 32 add $s1, $s2, $s3 $s1 = $s2 + $s3 (R & I format) subtract 0 and 34 sub $s1, $s2, $s3 $s1 = $s2 - $s3 Data Transfer (I format) Cond. Branch (I & R format) Uncond. Jump (J & R format) 331 Week 4.13 add immediate 8 addi $s1, $s2, 6 $s1 = $s2 + 6 or immediate 13 ori $s1, $s2, 6 $s1 = $s2 v 6 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 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 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 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 $s1, $s2, $s3 Spring 2006 The Code Translation Hierarchy C program compiler assembly code assembler object code library routines linker machine code executable loader memory 331 Week 4.14 Spring 2006 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 331 Week 4.15 good – smaller code size, faster execution Spring 2006 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 331 Week 4.16 Spring 2006 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 331 Week 4.17 Spring 2006 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 file header 331 Week 4.18 text segment data segment relocation symbol information table debugging information Spring 2006 MIPS (spim) Memory Allocation Memory Mem Map I/O $sp fffffffc Kernel Code & Data 8000 0080 7f f e f f fc Stack 230 words Dynamic data $gp Static data 1000 8000 ( 1004 0000) 1000 0000 Your Code PC 331 Week 4.19 0040 0000 Reserved 0000 0000 Spring 2006 Process that produces an executable file Source file compiler + assembler object file Source file compiler + assembler object file linker object file program library Source file 331 Week 4.20 compiler + assembler Executable file Spring 2006 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 331 Week 4.21 branches, jumps, and data addresses to external segments Spring 2006 Loader object file sub: object file . . . main: instructions Relocation records jal . . . jal ??? main: jal . . . jal ??? call, sub call, printf linker sub printf printf: . . . sub: C library printf: . . . 331 Week 4.22 executable file . . . Spring 2006 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.23 Spring 2006