CS224 Fall 2011 Chapter 2b Computer Organization CS224 Fall 2011 Chapter 2 b With thanks to M.J. Irwin, D. Patterson, and J. Hennessy for some lecture.

Slides:



Advertisements
Similar presentations
1 Lecture 3: MIPS Instruction Set Today’s topic:  More MIPS instructions  Procedure call/return Reminder: Assignment 1 is on the class web-page (due.
Advertisements

C OMPUTER O RGANIZATION AND D ESIGN The Hardware/Software Interface 5 th Edition Chapter 2 Instructions: Language of the Computer.
The University of Adelaide, School of Computer Science
The University of Adelaide, School of Computer Science
MIPS ISA-II: Procedure Calls & Program Assembly. (2) Module Outline Review ISA and understand instruction encodings Arithmetic and Logical Instructions.
ECE 232 L6.Assemb.1 Adapted from Patterson 97 ©UCBCopyright 1998 Morgan Kaufmann Publishers ECE 232 Hardware Organization and Design Lecture 6 MIPS Assembly.
ECE 15B Computer Organization Spring 2010 Dmitri Strukov Lecture 5: Data Transfer Instructions / Control Flow Instructions Partially adapted from Computer.
1 Lecture 4: Procedure Calls Today’s topics:  Procedure calls  Large constants  The compilation process Reminder: Assignment 1 is due on Thursday.
Procedure Calls Prof. Sirer CS 316 Cornell University.
Lecture 8 Sept 23 Completion of Ch 2 translating procedure into MIPS role of compilers, assemblers, linking, loading etc. pitfalls, conclusions Chapter.
Lecture 6: MIPS Instruction Set Today’s topic –Control instructions –Procedure call/return 1.
Chapter 2 Instructions: Language of the Computer CprE 381 Computer Organization and Assembly Level Programming, Fall 2013 Zhao Zhang Iowa State University.
Computer Architecture CSCE 350
1 Nested Procedures Procedures that don't call others are called leaf procedures, procedures that call others are called nested procedures. Problems may.
CPS3340 COMPUTER ARCHITECTURE Fall Semester, /17/2013 Lecture 12: Procedures Instructor: Ashraf Yaseen DEPARTMENT OF MATH & COMPUTER SCIENCE CENTRAL.
The University of Adelaide, School of Computer Science
Apr. 12, 2000Systems Architecture I1 Systems Architecture I (CS ) Lecture 6: Branching and Procedures in MIPS* Jeremy R. Johnson Wed. Apr. 12, 2000.
The University of Adelaide, School of Computer Science
CS3350B Computer Architecture Winter 2015 Lecture 4
331 Week 3. 1Spring 2005 Review: MIPS Organization Processor Memory 32 bits 2 30 words read/write addr read data write data word address (binary) 0…0000.
1 Lecture 3a: Supplemental Notes for Chapter 3 CS 447 Jason Bakos.
ENEE350 Spring07 1 Ankur Srivastava University of Maryland, College Park Adapted from Computer Organization and Design, Patterson & Hennessy, © 2005.”
Computer Structure - The Instruction Set (2) Goal: Implement Functions in Assembly  When executing a procedure (function in C) the program must follow.
Lecture 5 Sept 14 Goals: Chapter 2 continued MIPS assembly language instruction formats translating c into MIPS - examples.
331 Week 3. 1Fall 2003 Head’s Up  This week’s material l MIPS control flow operations (for, while, if-the-else, …) -Reading assignment - PH 3.5  Reminders.
COMPUTER ARCHITECTURE & OPERATIONS I Instructor: Hao Ji.
COMPUTER ARCHITECTURE & OPERATIONS I Instructor: Hao Ji.
Lecture 7: MIPS Instruction Set Today’s topic –Procedure call/return –Large constants Reminders –Homework #2 posted, due 9/17/
C OMPUTER O RGANIZATION AND D ESIGN The Hardware/Software Interface 5 th Edition Chapter 2 Instructions: Language of the Computer.
13/02/2009CA&O Lecture 04 by Engr. Umbreen Sabir Computer Architecture & Organization Instructions: Language of Computer Engr. Umbreen Sabir Computer Engineering.
Lecture 18: 11/5/2002CS170 Fall CS170 Computer Organization and Architecture I Ayman Abdel-Hamid Department of Computer Science Old Dominion University.
Lecture 8. MIPS Instructions #3 – Branch Instructions #1 Prof. Taeweon Suh Computer Science Education Korea University 2010 R&E Computer System Education.
Adapted from Computer Organization and Design, Patterson & Hennessy, UCB ECE232: Hardware Organization and Design Part 7: MIPS Instructions III
Character Data and 32-bit Constants (Lecture #20) ECE 445 – Computer Organization The slides included herein were taken from the materials accompanying.
Lecture 19: 11/7/2002CS170 Fall CS170 Computer Organization and Architecture I Ayman Abdel-Hamid Department of Computer Science Old Dominion University.
Computer Organization CS224 Fall 2012 Lessons 9 and 10.
11/02/2009CA&O Lecture 03 by Engr. Umbreen Sabir Computer Architecture & Organization Instructions: Language of Computer Engr. Umbreen Sabir Computer Engineering.
Procedure (Method) Calls Ellen Spertus MCS 111 September 25, 2003.
Lecture 4: MIPS Instruction Set
Computer Architecture CSE 3322 Lecture 4 crystal.uta.edu/~jpatters/cse3322 Assignments due 9/15: 3.7, 3.9, 3.11.
Chapter 2 CSF 2009 The MIPS Assembly Language. Stored Program Computers Instructions represented in binary, just like data Instructions and data stored.
Computer Organization CS224 Fall 2012 Lessons 7 and 8.
CPS3340 COMPUTER ARCHITECTURE Fall Semester, /22/2013 Lecture 12: Character Data Instructor: Ashraf Yaseen DEPARTMENT OF MATH & COMPUTER SCIENCE.
Computer Architecture CSE 3322 Lecture 4 Assignment: 2.4.1, 2.4.4, 2.6.1, , Due 2/10/09
Chapter 2 — Instructions: Language of the Computer — 1 Conditional Operations Branch to a labeled instruction if a condition is true – Otherwise, continue.
DR. SIMING LIU SPRING 2016 COMPUTER SCIENCE AND ENGINEERING UNIVERSITY OF NEVADA, RENO Session 11 Conditional Operations.
CMPUT Computer Organization and Architecture I1 CMPUT229 - Fall 2003 Topic4: Procedures José Nelson Amaral.
Lec 6Systems Architecture1 Systems Architecture Lecture 6: Branching and Procedures in MIPS Jeremy R. Johnson Anatole D. Ruslanov William M. Mongan Some.
DR. SIMING LIU SPRING 2016 COMPUTER SCIENCE AND ENGINEERING UNIVERSITY OF NEVADA, RENO Session 12 Procedure Calling.
Chapter 2 Instructions: Language of the Computer.
Computer Architecture & Operations I
Computer Architecture & Operations I
Rocky K. C. Chang Version 0.1, 25 September 2017
Lecture 5: Procedure Calls
Computer Architecture & Operations I
Lecture 6: Assembly Programs
The University of Adelaide, School of Computer Science
Lecture 4: MIPS Instruction Set
Procedures (Functions)
Procedures (Functions)
The University of Adelaide, School of Computer Science
Instructions - Type and Format
The University of Adelaide, School of Computer Science
Lecture 5: Procedure Calls
Chapter 2 Instructions: Language of the Computer part 2
The University of Adelaide, School of Computer Science
Lecture 6: Assembly Programs
Systems Architecture I
CSC3050 – Computer Architecture
Computer Architecture
Presentation transcript:

CS224 Fall 2011 Chapter 2b Computer Organization CS224 Fall 2011 Chapter 2 b With thanks to M.J. Irwin, D. Patterson, and J. Hennessy for some lecture slide contents

CS224 Fall 2011 Chapter 2b Conditional Operations  Branch to a labeled instruction if a condition is true Otherwise, continue sequentially  beq rs, rt, L1 if (rs == rt) branch to instruction labeled L1;  bne rs, rt, L1 if (rs != rt) branch to instruction labeled L1;  j L1 unconditional jump to instruction labeled L1 §2.7 Instructions for Making Decisions

CS224 Fall 2011 Chapter 2b Compiling If Statements  C code: if (i==j) f = g+h; else f = g-h; f, g, … in $s0, $s1, …  Compiled MIPS code: bne $s3, $s4, Else add $s0, $s1, $s2 j Exit Else: sub $s0, $s1, $s2 Exit: … Assembler calculates addresses

CS224 Fall 2011 Chapter 2b Compiling Loop Statements  C code: while (save[i] == k) i += 1; i in $s3, k in $s5, address of save in $s6  Hand “compiled” MIPS code: Loop: sll $t1, $s3, 2 add $t1, $t1, $s6 lw $t0, 0($t1) bne $t0, $s5, Exit addi $s3, $s3, 1 j Loop Exit: …  A real compiler will reduce this loop from 6 instructions to 3 (50% speedup). How? Bottom test_&_branching (back up, or out) saves 1 t1<- t1+4 (instead of sll, add, & addi) saves 2

CS224 Fall 2011 Chapter 2b Basic Blocks  A basic block is a sequence of instructions with No embedded branches (except at end) No branch targets (except at beginning)  A compiler identifies basic blocks for optimization  An advanced processor can accelerate execution of basic blocks

CS224 Fall 2011 Chapter 2b  MIPS conditional branch instructions: bne $s0, $s1, Ll#go to Ll if $s0  $s1 beq $s0, $s1, Ll#go to Ll if $s0=$s1 Ex: if (i==j) h = i + j; bne $s0, $s1, L1 add $s3, $s0, $s1 L1:... MIPS Control Flow Instructions  Instruction Format (I format): 0x bit offset  How is the branch destination address specified?

CS224 Fall 2011 Chapter 2b Specifying Branch Destinations  Use a register (like in lw and sw) added to the 16-bit offset which register? Instruction Address Register (the PC) -its use is automatically implied by instruction -PC gets updated (PC+4) during the fetch cycle so that it holds the address of the next instruction limits the branch distance to to (word) instructions from the (instruction after the) branch instruction, but most branches are local anyway PC Add 32 offset sign-extend from the low order 16 bits of the branch instruction branch dest address ? Add 4 32

CS224 Fall 2011 Chapter 2b  We have beq, bne, but what about other kinds of branches (e.g., branch-if-less-than)? For this, we need yet another instruction, slt  Set on less than instruction: slt $t0, $s0, $s1 # if $s0 < $s1 then # $t0 = 1else # $t0 = 0  Instruction format (R format):  Alternate versions of slt slti $t0, $s0, 25# if $s0 < 25 then $t0=1... sltu $t0, $s0, $s1# if $s0 < $s1 then $t0=1... sltiu $t0, $s0, 25# if $s0 < 25 then $t0= In Support of Branch Instructions x24

CS224 Fall 2011 Chapter 2b Signed vs. Unsigned  Signed comparison: slt, slti  Unsigned comparison: sltu, sltui  Example $s0 = $s1 = slt $t0, $s0, $s1 # signed -–1 < +1  $t0 = 1 sltu $t0, $s0, $s1 # unsigned -+4,294,967,295 > +1  $t0 = 0

CS224 Fall 2011 Chapter 2b Aside: More Branch Instructions  Can use slt, beq, bne, and the fixed value of 0 in register $zero to create other conditions less than blt $s1, $s2, Label less than or equal to ble $s1, $s2, Label greater than bgt $s1, $s2, Label great than or equal to bge $s1, $s2, Label slt $at, $s1, $s2#$at set to 1 if bne $at, $zero, Label#$s1 < $s2  Such branches are included in the instruction set as pseudo-instructions. These are recognized (and expanded) by the assembler Its why the assembler needs a reserved register ( $at )

CS224 Fall 2011 Chapter 2b Branch Instruction Design  Why not include blt, bge, etc in the MIPS ISA?  Hardware for <, ≥, … slower than =, ≠ Combining with branch involves more work per instruction, requiring a slower clock All instructions would be penalized!  beq and bne are the common case (Principle #3)  This is a good design compromise (Principle #4)

CS224 Fall 2011 Chapter 2b Bounds Check Shortcut  Treating signed numbers as if they were unsigned gives a low cost way of checking if 0 ≤ x < y (index out of bounds for arrays) sltu $t0, $s1, $t2 # $t0 = 0 if # $s1 > $t2 (max)# or $s1 < 0 (min) beq $t0, $zero, IOOB# go to IOOB if# $t0 = 0  The key is that negative integers in two’s complement look like large numbers in unsigned notation. Thus, an unsigned comparison of x < y also checks if x is negative as well as if x is less than y.

CS224 Fall 2011 Chapter 2b  MIPS procedure call instruction: jalProcedureAddress#jump and link  Saves PC+4 in register $ra to have a link to the next instruction for the procedure return  Machine format (J format):  Then can do procedure return with a jr$ra#return  Instruction format (R format): Instructions for Accessing Procedures 0x03 26 bit address x08 §2.8 Supporting Procedures in Computer Hardware

CS224 Fall 2011 Chapter 2b Six Steps in Execution of a Procedure 1. Main routine (caller) places parameters in a place where the procedure (callee) can access them $a0 - $a3 : four argument registers 2. Caller transfers control to the callee ( jal Dest) 3. Callee acquires the storage resources needed 4. Callee performs the desired task 5. Callee places the result value in a place where the caller can access it $v0 - $v1 : two value registers for result values 6. Callee returns control to the caller ( jr $ra) $ra : one return address register to return to the point of origin

CS224 Fall 2011 Chapter 2b Register Usage  $a0 – $a3: arguments (reg’s 4 – 7)  $v0, $v1: result values (reg’s 2 and 3)  $t0 – $t9: temporaries Can be overwritten by callee  $s0 – $s7: saved Must be saved/restored by callee !  $gp: global pointer for static data (reg 28)  $sp: stack pointer (reg 29)  $fp: frame pointer (reg 30)  $ra: return address (reg 31)  $gp, $sp, $fp, $ra must be saved/restored by callee !

CS224 Fall 2011 Chapter 2b Procedure Call Instructions  Procedure call: jump and link jal ProcedureLabel Address of following instruction put in $ra Jumps to target address  Procedure return: jump register jr $ra Copies $ra to program counter  Can also be used for computed jumps e.g., for case/switch statements

CS224 Fall 2011 Chapter 2b Leaf Procedure Example  C code: int leaf_example (int g, h, i, j) { int f; f = (g + h) - (i + j); return f; } Arguments g, …, j in $a0, …, $a3 f in $s0 (hence, need to save $s0 on stack) Result in $v0

CS224 Fall 2011 Chapter 2b Leaf Procedure Example  MIPS code: leaf_example: addi $sp, $sp, -4 sw $s0, 0($sp) add $t0, $a0, $a1 add $t1, $a2, $a3 sub $s0, $t0, $t1 add $v0, $s0, $zero lw $s0, 0($sp) addi $sp, $sp, 4 jr $ra Save $s0 on stack Procedure body Restore $s0 Result Return

CS224 Fall 2011 Chapter 2b Non-Leaf Procedures  Procedures that call other procedures  For nested call, caller needs to save on the stack: Its return address Any arguments and temporaries needed after the call  Restore from the stack after the call

CS224 Fall 2011 Chapter 2b Non-Leaf Procedure Example  C code: int fact (int n) { if (n < 1) return 1; else return n * fact(n - 1); } Argument n in $a0 Result in $v0

CS224 Fall 2011 Chapter 2b Non-Leaf Procedure Example  MIPS code: fact: addi $sp, $sp, -8 # adjust stack for 2 items sw $ra, 4($sp) # save return address sw $a0, 0($sp) # save argument slti $t0, $a0, 1 # test for n < 1 beq $t0, $zero, L1 addi $v0, $zero, 1 # if so, result is 1 addi $sp, $sp, 8 # pop 2 items from stack jr $ra # and return L1: addi $a0, $a0, -1 # else decrement n jal fact # recursive call lw $a0, 0($sp) # restore original n lw $ra, 4($sp) # and return address addi $sp, $sp, 8 # pop 2 items from stack mul $v0, $a0, $v0 # multiply to get result jr $ra # and return

CS224 Fall 2011 Chapter 2b Aside: Spilling Registers  What if the callee needs to use more registers than allocated to argument and return values? callee uses a stack – a last-in-first-out queue low addr high addr $sp  One of the general registers, $sp ( $29 ), is used to address the stack (which “grows” from high address to low address) add data onto the stack – push $sp = $sp – 4, then put data on stack at new $sp remove data from the stack – pop get data from stack at $sp, then $sp = $sp + 4 top of stack

CS224 Fall 2011 Chapter 2b Stacking of Subroutine Environments  Procedures are nested, there are multiple calls and returns  C is a “leaf” procedure, but B is a nested (non-leaf) procedure  The stack grows downward at each new call, shrinks upward at each return A: A CALL B B: A B CALL C A B C C: RET A B A

CS224 Fall 2011 Chapter 2b Aside: Allocating Space on the Stack  The segment of the stack containing a procedure’s saved registers and local variables is its procedure frame (aka activation record) The frame pointer ( $fp ) points to the first word of the frame of a procedure – providing a stable “base” register for the procedure -$fp is initialized using $sp on a call and $sp is restored using $fp on a return low addr high addr $sp Saved argument regs (if any) Saved return addr Saved local regs (if any) Local arrays & structures (if any) $fp

CS224 Fall 2011 Chapter 2b Local Data on the Stack  Local data allocated by callee e.g., C automatic variables  Procedure frame (activation record) Used by some compilers to manage stack storage

CS224 Fall 2011 Chapter 2b Memory Layout  Text: program code  Static data: global variables e.g., static variables in C, constant arrays and strings $gp initialized to address allowing ±offsets into this segment  Dynamic data: heap E.g., malloc in C, new in Java  Stack: automatic storage

CS224 Fall 2011 Chapter 2b Aside: Allocating Space on the Heap  Static data segment for constants and other static variables (e.g., arrays)  Dynamic data segment (aka heap) for structures that grow and shrink (e.g., linked lists) Allocate space on the heap with malloc() and free it with free() in C Memory 0x Text (Your code) Reserved Static data 0x x x x 7f f f f f f c Stack Dynamic data (heap) $sp $gp PC

CS224 Fall 2011 Chapter 2b Using Registers to Implement Procedures  Caller Save caller-saved registers $a0-$a3, $t0-$t9 Load arguments in $a0-$a3, rest on stack above $fp Execute jal instruction  Callee Setup Allocate memory in frame ($sp = $sp - frame) Save callee-saved registers $s0-$s7, $fp, $ra Create frame ($fp = $sp + frame size - 4)  Callee Return Place return value in $v0 and $v1 Restore any callee-saved registers ($fp, $ra,$s0-$s7…) Pop stack ($sp = $sp + frame size) Return by jr $ra

CS224 Fall 2011 Chapter 2b Calling Convention: Steps FP SP ra old FP $s0-$s7 FP SP First four arguments passed in registers Before call: Callee setup; step 1 FP SP Callee setup; step 2 ra old FP $s0-$s7 FP SP Callee setup; step 3 Adjust SP Save registers as needed Adjust FP

CS224 Fall 2011 Chapter 2b Compiling a Recursive Procedure  A procedure for calculating factorial int fact (int n) { if (n < 1) return 1; else return (n * fact (n-1)); }  A recursive procedure (one that calls itself!) fact (0) = 1 fact (1) = 1 * 1 = 1 fact (2) = 2 * 1 * 1 = 2 fact (3) = 3 * 2 * 1 * 1 = 6 fact (4) = 4 * 3 * 2 * 1 * 1 =  Assume n is passed in $a0 ; result returned in $v0

CS224 Fall 2011 Chapter 2b Compiling a Recursive Procedure fact:addi$sp, $sp, -8#adjust stack pointer sw$ra, 4($sp)#save return address sw$a0, 0($sp)#save argument n slti$t0, $a0, 1#test for n < 1 beq$t0, $zero, L1#if n >=1, go to L1 addi$v0, $zero, 1#else return 1 in $v0 addi$sp, $sp, 8#adjust stack pointer jr$ra#return to caller L1:addi$a0, $a0, -1#n >=1, so decrement n jalfact#call fact with (n-1) #bk f is where fact returns bk_f:lw$a0, 0($sp)#restore argument n lw$ra, 4($sp)#restore return address addi$sp, $sp, 8#adjust stack pointer mul$v0, $a0, $v0#$v0 = n * fact(n-1) jr$ra#return to caller

CS224 Fall 2011 Chapter 2b A Look at the Stack for $a0 = 2, Part 1  $sp $ra $a0 $v0 old TOS  Stack state after execution of first encounter with the jal instruction (which is the second call to fact routine, with $a0 now holding 1) save return address to caller routine (i.e., location in the main routine where first call to fact is made) on the stack save original value of $a0 on the stack

CS224 Fall 2011 Chapter 2b A Look at the Stack for $a0 = 2, Part 1  $sp $ra $a0 $v0  $sp caller rt addr $a0 = 2 21 bk_f old TOS  Stack state after execution of first encounter with the jal instruction (which is the second call to fact routine, with $a0 now holding 1) saved return address to caller routine (i.e., location in the main routine where first call to fact is made) on the stack saved original value of $a0 on the stack

CS224 Fall 2011 Chapter 2b A Look at the Stack for $a0 = 2, Part 2  $sp $ra $a0 $v0 old TOS  Stack state after execution of second encounter with the jal instruction (which is the third call to fact routine, with $a0 now holding 0) save return address of instruction in caller routine (instruction after jal ) on the stack save previous value of $a0 on the stack

CS224 Fall 2011 Chapter 2b A Look at the Stack for $a0 = 2, Part 2 $ra $a0 $v0  $sp caller rt addr $a0 = 2 10 bk_f old TOS  $sp $a0 = 1 bk_f  Stack state after execution of second encounter with the jal instruction (which is the third call to fact routine, with $a0 now holding 0) saved return address of instruction in caller routine (instruction after jal ) on the stack saved previous value of $a0 on the stack

CS224 Fall 2011 Chapter 2b A Look at the Stack for $a0 = 2, Part 3  $sp $ra $a0 $v0 old TOS  Stack state after execution of the only encounter with the first jr instruction (return from fact(0) routine, with $v0 set to 1) stack pointer updated and re- updated to point to place it held at third call to fact

CS224 Fall 2011 Chapter 2b A Look at the Stack for $a0 = 2, Part 3 $ra $a0 $v0  $sp bk_f $a0 = 1 0 old TOS  $sp $a0 = 0 bk_f $a0 = 2 caller rt addr 1  $sp  Stack state after execution of the only encounter with the first jr instruction (return from fact(0) routine, with $v0 set to 1) stack pointer updated and re- updated to point to place it held at third call to fact

CS224 Fall 2011 Chapter 2b A Look at the Stack for $a0 = 2, Part 4  $sp $ra $a0 $v0 old TOS  Stack state after execution of first encounter with the second jr instruction (return from fact(1) routine, after updating $v0 to 1 * 1) return address to caller routine ( bk_f in fact routine) restored to $ra from the stack previous value of $a0 restored from the stack stack pointer re-updated to point to place it held at second call to fact

CS224 Fall 2011 Chapter 2b A Look at the Stack for $a0 = 2, Part 4 $ra $a0 $v0  $sp bk_f $a0 = 1 0 old TOS $a0 = 0 bk_f $a0 = 2 caller rt addr 1  $sp 1 bk_f 1 * 1  Stack state after execution of the first encounter with the second jr instruction (return from fact(1) routine, after updating $v0 to 1 * 1) return address to caller routine ( bk_f in fact routine) restored to $ra from the stack previous value of $a0 restored from the stack stack pointer re-updated to point to place it held at second call to fact

CS224 Fall 2011 Chapter 2b A Look at the Stack for $a0 = 2, Part 5  $sp $ra $a0 $v0 old TOS  Stack state after execution of first encounter with the second jr instruction (return from fact(2) routine after updating $v0 to 2 * 1 * 1) return address to caller routine ( bk_f in fact routine) restored to $ra from the stack previous value of $a0 restored from the stack stack pointer re-updated to point to place it held at first call to fact

CS224 Fall 2011 Chapter 2b A Look at the Stack for $a0 = 2, Part 5 $ra $a0 $v0  $sp bk_f $a0 = 1 1 old TOS $a0 = 0 bk_f $a0 = 2 caller rt addr 1 * 1  $sp 2 bk_f 2 * 1 * 1  Stack state after execution of second encounter with the second jr instruction (return from fact(2) routine, after updating $v0 to 2 * 1 * 1) return address to caller routine (main routine) restored to $ra from the stack original value of $a0 restored from the stack stack pointer re-updated to point to place it held at first call to fact Caller rt addr

CS224 Fall 2011 Chapter 2b Character Data  Byte-encoded character sets ASCII: 128 characters -95 graphic, 33 control Latin-1: 256 characters -ASCII, +96 more graphic characters  Unicode: 32-bit character set Used in Java, C++ wide characters, … Most of the world’s alphabets, plus symbols UTF-8, UTF-16: variable-length encodings §2.9 Communicating with People

CS224 Fall 2011 Chapter 2b Byte/Halfword Operations  Could use bitwise operations  MIPS byte/halfword load/store String processing is a common case lb rt, offset(rs) lh rt, offset(rs) Sign extend to 32 bits in rt lbu rt, offset(rs) lhu rt, offset(rs) Zero extend to 32 bits in rt sb rt, offset(rs) sh rt, offset(rs) Store just rightmost byte/halfword

CS224 Fall 2011 Chapter 2b String Copy Example  C code (naive): Null-terminated string void strcpy (char x[], char y[]) { int i; i = 0; while ((x[i]=y[i])!='\0') i += 1; } Addresses of x, y in $a0, $a1 i in $s0

CS224 Fall 2011 Chapter 2b String Copy Example  MIPS code: strcpy: addi $sp, $sp, -4 # adjust stack for 1 item sw $s0, 0($sp) # save $s0 add $s0, $zero, $zero # i = 0 L1: add $t1, $s0, $a1 # addr of y[i] in $t1 lbu $t2, 0($t1) # $t2 = y[i] add $t3, $s0, $a0 # addr of x[i] in $t3 sb $t2, 0($t3) # x[i] = y[i] beq $t2, $zero, L2 # exit loop if y[i] == 0 addi $s0, $s0, 1 # i = i + 1 j L1 # next iteration of loop L2: lw $s0, 0($sp) # restore saved $s0 addi $sp, $sp, 4 # pop 1 item from stack jr $ra # and return