# Computer Science 2500 Computer Organization Rensselaer Polytechnic Institute Spring Topic Notes: MIPS Programming

Size: px
Start display at page:

Download "Computer Science 2500 Computer Organization Rensselaer Polytechnic Institute Spring Topic Notes: MIPS Programming"

## Transcription

1 Computer Science 2500 Computer Organization Rensselaer Polytechnic Institute Spring 2009 Topic Notes: MIPS Programming We spent some time looking at the MIPS Instruction Set Architecture. We will now consider how to program in MIPS assembly language. Our arsenal of MIPS assembly instructions now include: add \$a, \$b, \$c sub \$a, \$b, \$c addi \$a, \$b, n lw \$a, n(\$b) sw \$a, n(\$b) sll \$a, \$b, n srl \$a, \$b, n and \$a, \$b, \$c andi \$a, \$b, n or \$a, \$b, \$c ori \$a, \$b, n nor \$a, \$b, \$c beq \$a, \$b, L bne \$a, \$b, L j L Control Structures in MIPS Assembly Suppose we want to implement a while loop in MIPS assembly. Consider the high-level language code:

2 while (a!=b) a += i; where a is stored in register \$s0, b in \$s1 and the increment i is in \$s2. Our MIPS assembly code might look like this: Loop: beq \$s0, \$s1, EndLoop # if a==b goto EndLoop add \$s0, \$s0, \$s2 # a = a + i j Loop # goto Loop EndLoop:... code after loop... Note that we use a beq instruction here as we want to branch in the case where we no longer wish to execute the contents of the loop. Now consider a slightly more complicated loop: while (a[i] == k) i += j; We need to deal with an array access here. Suppose we have made the following register assignments: The start of array a is in \$s3, i is in \$s0, k is in \$s1, and j is in \$s2. All are int values. One way to implement this code would be: LoopTop: sll \$t0, \$s0, 2 # t0 = i * 4 add \$t0, \$t0, \$s3 # t0 = address of a[i] lw \$t1, 0(\$t0) # t1 = contents of a[i] bne \$t1, \$s1, EndLoop # if a[i]!= k, goto EndLoop add \$s0, \$s0, \$s2 # i = i + j j LoopTop # jump back to the top of the loop EndLoop:... code after loop... A few notes: We need to multiply i by 4 to get the correct offset, since we re assuming a is an array of word-sized values. We might be tempted to write lw \$t1, \$t0(\$s3) 2

3 to access the value at an offset of \$t0 from our base register \$s3. But that is not valid MIPS - the offset part of the lw and sw instructions needs to be a constant, not a register. The MIPS designers could have provided such an instruction (it would be R-format instead of I-format), but they chose not to. Before we can complete our next example, we need a couple of additional instructions reading and writing single bytes from memory. These instructions, lb for load byte and sb for store byte, work just like the lw and sw instructions except that only single-byte values are processed. lb \$a, n(\$b) Loads the single byte at an offset of n from register \$b and stores it, sign-extended, into register \$a. sb \$a, n(\$b) Stores the byte in the bottom 8 bits of register \$a into memory at an offset of n from register \$b. String Processing Examples Armed with these instructions, we can write our next example: a string copy function like C s strcpy: strcpy(dest, src); Recall that C strings are terminated with a null (0) character. For now, we ll just look at the main loop of this function. Assume register \$s1 holds the address of the start of the dest string and that \$s2 holds the address of the start of the src string. Our task is to write a loop that copies characters (bytes) from the source string to the destination string. LoopTop: lb \$t0, 0(\$s2) # temp reg = char at \$s2 sb \$t0, 0(\$s1) # char at \$s1 gets temp reg addi \$s2, \$s2, 1 # increment \$s2 addi \$s1, \$s1, 1 # increment \$s1 bne \$t0, \$zero, LoopTop # branch if we didn t just copy a null For another example: 3

4 char a[11];... put something in a... for (i=0; i<10; i++) { a[i+1] = a[i]; } Assuming \$s0 contains the address of a, here s one way to write this: add \$s0, \$zero, \$zero # i=0 ForLoop: slti \$t1, \$s0, 10 # i<10? beq \$t1, \$zero, LoopEnd # if done, branch out add \$t2, \$s0, \$s1 # t2 gets address of a[i] lb \$t3, 0(\$t2) # t3 gets a[i] addi \$t2, \$t2, 1 # t2 gets address of a[i+1] sb \$t3, 0(\$t2) # a[i+1] gets t3 addi \$s0, \$s0, 1 # i++ j ForLoop # back to check loop condition LoopEnd: MIPS Subroutines and Programs You are all familiar with function/method calls in high-level languages. In assembly language, we usually refer to these as subroutines. The idea is the same as a function or method call the program branches from its sequence of instructions to execute a chunk of code elsewhere, then returns to continue where it left off. We ll now look at how to write and call subroutines in MIPS assembly. Special Registers and Instructions Recall that there were several registers reserved to help support subroutine calls: \$a0-\$a4: argument registers a place for the caller to place values to send to the subroutine. \$v0, \$v1: return value registers a place for subroutines to return values to the caller. \$ra: return address register where to resume executing the caller when the subroutine is finished. We also have a couple of special jump instructions: Jump and Link: 4

5 jal address This instruction puts the address of the next instruction (PC+4) into register \$ra, then jumps to the address. This is a J-format instruction, just like the standard jump instruction (j). Jump to Register: jr \$a Jumps to the address specified in the given register. This is an R-format instruction. Assuming the subroutine hasn t changed the \$ra register, this can be used to return from the subroutine. Registers and the Stack We said previously that the s registers \$s0-\$s7 are the ones assigned to variables and the t registers \$t0-\$t7 are temporary values. This becomes important when we start looking at subroutines. The accepted convention for register use by subroutines: \$t0-\$t7 are always available for use by a subroutine if a subroutine calls another subroutine, it must assume that the called subroutine will modify \$t0-\$t7. if this is a problem for the calling subroutine, it should save any values it has in \$t0- \$t7 to memory and restore them after the subroutine call. \$s0-\$s7 should be unchanged by a subroutine call if a subroutine calls another subroutine, it can expect its values in \$s0-\$s7 to remain upon return. if the called subroutine wishes to make use of \$s0-\$s7, it should save the caller s values in any of these registers it will use in memory, then restore them before return. Since subroutines can be called by anyone, we don t know which s registers, if any, are important to the caller. So we have to save these if we use them. So where do we save values in memory when we need to save them? On the stack. The stack is a section of memory dedicated to saving registers to manage subroutine calls. 5

7 bne \$t0, \$zero, LoopTop # branch if we didn t just copy a null lw \$s1, 0(\$sp) # restore s1 lw \$s2, 4(\$sp) # restore s2 addi \$sp, \$sp, 8 # restore sp jr \$ra # return from subroute Note that we could so something simpler here: save and restore \$a0 and \$a1 and use those in place of \$s1 and \$s2 throughout. A Recursive Example We will develop a MIPS assembly subroutine to implement the following C function: int factorial (int x) { if (x<1) return 1; return x * factorial(x-1); Since this subroutine calls another subroutine (itself) we need to save \$ra and any temp registers we care about before making the recursive call. We will assume a subroutine multiply exists and we will use that to do our multiplication to get extra practice with subroutines. Here is some code for this: factorial: # make space for 2 words on the stack addi \$sp, \$sp, -8 # save \$ra and \$a0 on the stack sw \$a0, 4(\$sp) sw \$ra, 0(\$sp) slti \$t0, \$a0, 1 # is x < 1? beq \$t0, \$zero, L1 # if no, skip over if part # x >= 1, just return 1 addi \$v0, \$zero, 1 # return value is 1 # we could restore \$a0 and \$ra but we know they haven t # changed when we take this quick exit, so let s not # but we still need to put \$sp back the way we found it addi \$sp, \$sp, 8 jr \$ra # return to caller 7

8 # here, x>=1 so we need to make a recursive call L1: addi \$a0, \$a0, -1 # get x-1 for the parameter jal factorial # recursive call, will put answer in \$v0 # We now want to set up for the multiply, but we destroyed \$a0 # above, but have it on the stack, so let s load it lw \$a0, 4(\$sp) add \$a1, \$v0, \$zero # put factorial(x-1) result into \$a1 jal multiply # multiply \$a0*\$a1, put result in \$v0 # \$v0 is where we want our answer, so no work there # but multiply could have changed \$a0 and did change \$ra lw \$ra, 0(\$sp) # restore \$ra lw \$a0, 4(\$sp) # restore \$a0 addi \$sp, \$sp, 8 # restore \$sp jr \$ra # return to caller Trace through this with the call factorial(3). Complete Programs and SPIM We will use a simulator called SPIM to execute MIPS programs. SPIM reads MIPS assembly language programs SPIM simulates the execution of each instruction SPIM displays values of registers and memory SPIM allows breakpoints and step-by-step execution SPIM provides primitive I/O to allow interactive processing Three SPIM versions are available: spim the command-line version xspim the X11 version (Macs, Unix workstations) PCspim Windows version We will grade submissions with spim, but you are welcome to use any version you wish when developing MIPS programs. 8

9 A complete program consists of several parts, including the MIPS assembly code we have been considering in our previous examples. Our first complete example will show a few of the parts of a MIPS program beyond what we have seen. See: /cs/terescoj/shared/cs2500/examples/spim-simple/simple.s Things to notice about this example: Comments in MIPS assembly are any part of a line after a # character. We can define variables in the.data portion of the program. Here, we define three word-sized variables with initial values. The names are the labels, the initial values are given after the.word directive. These labels are local labels, meaning that they exist only within this assembly source file. We also define an uninitialized word-sized variable with the.space directive and 4 for the number of bytes of space to allocate. The program is defined in the.text portion the code section. We include.align 2 to make sure our code starts on a word boundary..align n forces the next defined item to align on a 2 n -byte boundary. (Note that.globl main makes the main label an external, or global label, which allows the main subroutine to be callable from outside of this file (in this case, by the simulator). The program itself is defined starting at the main: label. Note that we can use lw and sw to load registers from and store registers to named memory locations. Our first example of SPIM s primitive I/O is this syscall. syscall can perform one of several functions, as determined by the value in \$v0. Here, we have a 1 in \$v0, which specifies print int. The int to print must be placed in \$a0. Finally, when main completes, we return from the subroutine with jr \$ra. To run this at the command line: spim simple.s This should print our answer. We can learn much more about the execution of the program running SPIM in interactive mode. Run SPIM without any command-line parameters to get the (spim) prompt, and type help to see the options available. 9

10 . Some things to notice when stepping through our program: Execution starts at 0x by default, which is the code that sets up the call to main. After a few steps, main gets invoked with a jal call. When we get to main, we find that we are executing a lui instruction rather than the expected lw. Why? The lw instruction requires a base register and offset: lw \$t0, offset(\$base) The assembler allows us to write lw \$t0, num1 (which constitues a different addressing mode) and inserts appropriate instructions to perform a load from a labelled memory location. It computes the appropriate address, loads it into the reserved assembler register \$at, then issues a lw instruction in the machine s memory addressing mode. Another simple example: See: /cs/terescoj/shared/cs2500/examples/spim-simple/hello.c A few things to note: We can define a string constant as part of our data segment with an.asciiz directive. The la is a pseudoinstruction that directs the assembler to load the given register with the address of the given label. A syscall with \$v0 set to 4 is the print string operation, and will print the nullterminated string starting at the address in \$a0. Next, we look at a complete version of the factorial program. See: /cs/terescoj/shared/cs2500/examples/spim-factorial/factorial.s The factorial subroutine is identical to what we looked at last time. We fill in the missing multiply routine with the one you did for the lecture assignment, changed to use \$a0 and \$a1 as the parameters and to put the answer into \$v0. The main subroutine will use two s registers and will call subroutines, so we begin by pushing \$s0, \$s1, and \$ra onto the stack. Note that SPIM initialized \$sp for us appropriately. 10

11 We print a prompt string with the print string syscall and then read in an int from the keyboard with the read int syscall. Note: a complete list of syscall codes is in Figure B.9.1. After the call to factorial, we use a series of syscalls to print the answer. Finally, we pop the stack and return from main. MIPS Pseudoinstructions We have mentioned the idea of pseudoinstructions a few times. These are instructions that exist in MIPS assembly that don t exist in machine language. The pseudoinstructions map to one or more MIPS machine instructions. These exist for convenience of the programmer (human or compiler). Here are a few common MIPS pseudoinstructions: move \$a \$b move (copy) contents of register \$b to register \$a. This is assembled into add \$s0, \$s1, \$zero. blt \$a, \$b, L branch on less than if \$a is less than \$b, branch to label L. This is assembled into two machine instructions: slt \$at, \$a, \$b bne \$at, L Note the use of the assembler reserved register \$at. li load immediate la load address sgt, sle, sge set on... bge, bgt, ble, blt conditional branches 11

Branch Addressing Branch instructions specify Opcode, two registers, target address Most branch targets are near branch Forward or backward op rs rt constant or address 6 bits 5 bits 5 bits 16 bits PC-relative

### We will study the MIPS assembly language as an exemplar of the concept.

MIPS Assembly Language 1 We will study the MIPS assembly language as an exemplar of the concept. MIPS assembly instructions each consist of a single token specifying the command to be carried out, and

### Lecture 5: Procedure Calls

Lecture 5: Procedure Calls Today s topics: Procedure calls and register saving conventions 1 Example Convert to assembly: while (save[i] == k) i += 1; i and k are in \$s3 and \$s5 and base of array save[]

### Topic Notes: MIPS Instruction Set Architecture

Computer Science 220 Assembly Language & Comp. Architecture Siena College Fall 2011 Topic Notes: MIPS Instruction Set Architecture vonneumann Architecture Modern computers use the vonneumann architecture.

### Chapter 2. Computer Abstractions and Technology. Lesson 4: MIPS (cont )

Chapter 2 Computer Abstractions and Technology Lesson 4: MIPS (cont ) Logical Operations Instructions for bitwise manipulation Operation C Java MIPS Shift left >>> srl Bitwise

### MIPS function continued

MIPS function continued Review Functions Series of related instructions one after another in memory Called through the jal instruction Pointed to by a label like any other Returns by calling Stack Top

### COMP 303 Computer Architecture Lecture 3. Comp 303 Computer Architecture

COMP 303 Computer Architecture Lecture 3 Comp 303 Computer Architecture 1 Supporting procedures in computer hardware The execution of a procedure Place parameters in a place where the procedure can access

### Chapter 2A Instructions: Language of the Computer

Chapter 2A Instructions: Language of the Computer Copyright 2009 Elsevier, Inc. All rights reserved. Instruction Set The repertoire of instructions of a computer Different computers have different instruction

### Lecture 6: Assembly Programs

Lecture 6: Assembly Programs Today s topics: Procedures Examples Large constants The compilation process A full example 1 Procedures Local variables, AR, \$fp, \$sp Scratchpad and saves/restores, \$fp Arguments

### ECE 30 Introduction to Computer Engineering

ECE 30 Introduction to Computer Engineering Study Problems, Set #3 Spring 2015 Use the MIPS assembly instructions listed below to solve the following problems. arithmetic add add sub subtract addi add

### Chapter 2. Instructions:

Chapter 2 1 Instructions: Language of the Machine More primitive than higher level languages e.g., no sophisticated control flow Very restrictive e.g., MIPS Arithmetic Instructions We ll be working with

### MIPS R-format Instructions. Representing Instructions. Hexadecimal. R-format Example. MIPS I-format Example. MIPS I-format Instructions

Representing Instructions Instructions are encoded in binary Called machine code MIPS instructions Encoded as 32-bit instruction words Small number of formats encoding operation code (opcode), register

### Common Problems on Homework

MIPS Functions Common Problems on Homework 1.3: Convert -3000 ten to binary in 8bit, 16bit, and 32bit Even though it overflows with 8bits, there is plenty of room with 16 and 32 bit. Common Problems on

### Procedure Calling. Procedure Calling. Register Usage. 25 September CSE2021 Computer Organization

CSE2021 Computer Organization Chapter 2: Part 2 Procedure Calling Procedure (function) performs a specific task and return results to caller. Supporting Procedures Procedure Calling Calling program place

### CSE Lecture In Class Example Handout

CSE 30321 Lecture 07-09 In Class Example Handout Part A: A Simple, MIPS-based Procedure: Swap Procedure Example: Let s write the MIPS code for the following statement (and function call): if (A[i] > A

### Do-While Example. In C++ In assembly language. do { z--; while (a == b); z = b; loop: addi \$s2, \$s2, -1 beq \$s0, \$s1, loop or \$s2, \$s1, \$zero

Do-While Example In C++ do { z--; while (a == b); z = b; In assembly language loop: addi \$s2, \$s2, -1 beq \$s0, \$s1, loop or \$s2, \$s1, \$zero 25 Comparisons Set on less than (slt) compares its source registers

### Computer Architecture

Computer Architecture Chapter 2 Instructions: Language of the Computer Fall 2005 Department of Computer Science Kent State University Assembly Language Encodes machine instructions using symbols and numbers

### CENG3420 Lecture 03 Review

CENG3420 Lecture 03 Review Bei Yu byu@cse.cuhk.edu.hk 2017 Spring 1 / 38 CISC vs. RISC Complex Instruction Set Computer (CISC) Lots of instructions of variable size, very memory optimal, typically less

### Lecture 5: Procedure Calls

Lecture 5: Procedure Calls Today s topics: Memory layout, numbers, control instructions Procedure calls 1 Memory Organization The space allocated on stack by a procedure is termed the activation record

### Chapter 2. Instructions: Language of the Computer. Adapted by Paulo Lopes

Chapter 2 Instructions: Language of the Computer Adapted by Paulo Lopes Instruction Set The repertoire of instructions of a computer Different computers have different instruction sets But with many aspects

### Control Instructions. Computer Organization Architectures for Embedded Computing. Thursday, 26 September Summary

Control Instructions Computer Organization Architectures for Embedded Computing Thursday, 26 September 2013 Many slides adapted from: Computer Organization and Design, Patterson & Hennessy 4th Edition,

### Control Instructions

Control Instructions Tuesday 22 September 15 Many slides adapted from: and Design, Patterson & Hennessy 5th Edition, 2014, MK and from Prof. Mary Jane Irwin, PSU Summary Previous Class Instruction Set

### comp 180 Lecture 10 Outline of Lecture Procedure calls Saving and restoring registers Summary of MIPS instructions

Outline of Lecture Procedure calls Saving and restoring registers Summary of MIPS instructions Procedure Calls A procedure of a subroutine is like an agent which needs certain information to perform a

### ELEC / Computer Architecture and Design Fall 2013 Instruction Set Architecture (Chapter 2)

ELEC 5200-001/6200-001 Computer Architecture and Design Fall 2013 Instruction Set Architecture (Chapter 2) Victor P. Nelson, Professor & Asst. Chair Vishwani D. Agrawal, James J. Danaher Professor Department

### Machine Language Instructions Introduction. Instructions Words of a language understood by machine. Instruction set Vocabulary of the machine

Machine Language Instructions Introduction Instructions Words of a language understood by machine Instruction set Vocabulary of the machine Current goal: to relate a high level language to instruction

### CSCI 402: Computer Architectures. Instructions: Language of the Computer (3) Fengguang Song Department of Computer & Information Science IUPUI.

CSCI 402: Computer Architectures Instructions: Language of the Computer (3) Fengguang Song Department of Computer & Information Science IUPUI Recall Big endian, little endian Memory alignment Unsigned

### Chapter 3. Instructions:

Chapter 3 1 Instructions: Language of the Machine More primitive than higher level languages e.g., no sophisticated control flow Very restrictive e.g., MIPS Arithmetic Instructions We ll be working with

### Solutions for Chapter 2 Exercises

Solutions for Chapter 2 Exercises 1 Solutions for Chapter 2 Exercises 2.2 By lookup using the table in Figure 2.5 on page 62, 7fff fffa hex = 0111 1111 1111 1111 1111 1111 1111 1010 two = 2,147,483,642

### Instruction Set Architecture part 1 (Introduction) Mehran Rezaei

Instruction Set Architecture part 1 (Introduction) Mehran Rezaei Overview Last Lecture s Review Execution Cycle Levels of Computer Languages Stored Program Computer/Instruction Execution Cycle SPIM, a

### Lecture 7: Examples, MARS, Arithmetic

Lecture 7: Examples, MARS, Arithmetic Today s topics: More examples MARS intro Numerical representations 1 Dealing with Characters Instructions are also provided to deal with byte-sized and half-word quantities:

### CS 61c: Great Ideas in Computer Architecture

MIPS Functions July 1, 2014 Review I RISC Design Principles Smaller is faster: 32 registers, fewer instructions Keep it simple: rigid syntax, fixed instruction length MIPS Registers: \$s0-\$s7,\$t0-\$t9, \$0

### SPIM Instruction Set

SPIM Instruction Set This document gives an overview of the more common instructions used in the SPIM simulator. Overview The SPIM simulator implements the full MIPS instruction set, as well as a large

### Computer Architecture Instruction Set Architecture part 2. Mehran Rezaei

Computer Architecture Instruction Set Architecture part 2 Mehran Rezaei Review Execution Cycle Levels of Computer Languages Stored Program Computer/Instruction Execution Cycle SPIM, a MIPS Interpreter

### Computer Science 324 Computer Architecture Mount Holyoke College Fall Topic Notes: MIPS Instruction Set Architecture

Computer Science 324 Computer Architecture Mount Holyoke College Fall 2009 Topic Notes: MIPS Instruction Set Architecture vonneumann Architecture Modern computers use the vonneumann architecture. Idea:

### Architecture II. Computer Systems Laboratory Sungkyunkwan University

MIPS Instruction ti Set Architecture II Jin-Soo Kim (jinsookim@skku.edu) Computer Systems Laboratory Sungkyunkwan University http://csl.skku.edu Making Decisions (1) Conditional operations Branch to a

### Lecture 2. Instructions: Language of the Computer (Chapter 2 of the textbook)

Lecture 2 Instructions: Language of the Computer (Chapter 2 of the textbook) Instructions: tell computers what to do Chapter 2 Instructions: Language of the Computer 2 Introduction Chapter 2.1 Chapter

### ECE232: Hardware Organization and Design

ECE232: Hardware Organization and Design Lecture 6: Procedures Adapted from Computer Organization and Design, Patterson & Hennessy, UCB Overview Procedures have different names in different languages Java:

### Assembly Language Programming. CPSC 252 Computer Organization Ellen Walker, Hiram College

Assembly Language Programming CPSC 252 Computer Organization Ellen Walker, Hiram College Instruction Set Design Complex and powerful enough to enable any computation Simplicity of equipment MIPS Microprocessor

### Assembly labs start this week. Don t forget to submit your code at the end of your lab section. Download MARS4_5.jar to your lab PC or laptop.

CSC258 Week 10 Logistics Assembly labs start this week. Don t forget to submit your code at the end of your lab section. Download MARS4_5.jar to your lab PC or laptop. Quiz review A word-addressable RAM

### ECE260: Fundamentals of Computer Engineering

Accessing and Addressing Memory James Moscola Dept. of Engineering & Computer Science York College of Pennsylvania Based on Computer Organization and Design, 5th Edition by Patterson & Hennessy American

### Compiling Code, Procedures and Stacks

Compiling Code, Procedures and Stacks L03-1 RISC-V Recap Computational Instructions executed by ALU Register-Register: op dest, src1, src2 Register-Immediate: op dest, src1, const Control flow instructions

### Thomas Polzer Institut für Technische Informatik

Thomas Polzer tpolzer@ecs.tuwien.ac.at Institut für Technische Informatik Branch to a labeled instruction if a condition is true Otherwise, continue sequentially beq rs, rt, L1 if (rs == rt) branch to

### MIPS Instruction Set Architecture (2)

MIPS Instruction Set Architecture (2) Jinkyu Jeong (jinkyu@skku.edu) Computer Systems Laboratory Sungkyunkwan University http://csl.skku.edu EEE3050: Theory on Computer Architectures, Spring 2017, Jinkyu

### COMPUTER ORGANIZATION AND DESIGN

COMPUTER ORGANIZATION AND DESIGN 5 th The Hardware/Software Interface Edition Chapter 2 Instructions: Language of the Computer 2.1 Introduction Instruction Set The repertoire of instructions of a computer

### ECE 473 Computer Architecture and Organization Lab 4: MIPS Assembly Programming Due: Wednesday, Oct. 19, 2011 (30 points)

ECE 473 Computer Architecture and Organization Lab 4: MIPS Assembly Programming Due: Wednesday, Oct. 19, 2011 (30 points) Objectives: Get familiar with MIPS instructions Assemble, execute and debug MIPS

### 1/26/2014. Previously. CSE 2021: Computer Organization. The Load/Store Family (1) Memory Organization. The Load/Store Family (2)

CSE 202: Computer Organization Lecture-4 Code Translation-2 Memory, Data transfer instructions, Data segment,, Procedures, Stack Shakil M. Khan (adapted from Prof. Roumani) Previously Registers \$s0 - \$s7,

### Computer Science and Engineering 331. Midterm Examination #1. Fall Name: Solutions S.S.#:

Computer Science and Engineering 331 Midterm Examination #1 Fall 2000 Name: Solutions S.S.#: 1 41 2 13 3 18 4 28 Total 100 Instructions: This exam contains 4 questions. It is closed book and notes. Calculators

### Instructions: Assembly Language

Chapter 2 Instructions: Assembly Language Reading: The corresponding chapter in the 2nd edition is Chapter 3, in the 3rd edition it is Chapter 2 and Appendix A and in the 4th edition it is Chapter 2 and

### Lecture 6 Decision + Shift + I/O

Lecture 6 Decision + Shift + I/O Instructions so far MIPS C Program add, sub, addi, multi, div lw \$t0,12(\$s0) sw \$t0, 12(\$s0) beq \$s0, \$s1, L1 bne \$s0, \$s1, L1 j L1 (unconditional branch) slt reg1,reg2,reg3

### MODULE 4 INSTRUCTIONS: LANGUAGE OF THE MACHINE

MODULE 4 INSTRUCTIONS: LANGUAGE OF THE MACHINE 1 ARCHITECTURE MODEL The basic instruction set of a computer is comprised of sequences of REGISTER TRANSFERS. Example: Add A, B, C Register B # A

### COMP MIPS instructions 2 Feb. 8, f = g + h i;

Register names (save, temporary, zero) From what I have said up to now, you will have the impression that you are free to use any of the 32 registers (\$0,..., \$31) in any instruction. This is not so, however.

### Computer Organization and Structure. Bing-Yu Chen National Taiwan University

Computer Organization and Structure Bing-Yu Chen National Taiwan University Instructions: Language of the Computer Operations and Operands of the Computer Hardware Signed and Unsigned Numbers Representing

### Lab 4 : MIPS Function Calls

Lab 4 : MIPS Function Calls Name: Sign the following statement: On my honor, as an Aggie, I have neither given nor received unauthorized aid on this academic work 1 Objective The objective of this lab

### Lec 10: Assembler. Announcements

Lec 10: Assembler Kavita Bala CS 3410, Fall 2008 Computer Science Cornell University Announcements HW 2 is out Due Wed after Fall Break Robot-wide paths PA 1 is due next Wed Don t use incrementor 4 times

### MIPS Functions and the Runtime Stack

MIPS Functions and the Runtime Stack COE 301 Computer Organization Prof. Muhamed Mudawar College of Computer Sciences and Engineering King Fahd University of Petroleum and Minerals Presentation Outline

### Chapter 2. Instructions: Language of the Computer

Chapter 2 Instructions: Language of the Computer Instruction Set The repertoire of instructions of a computer Different computers have different instruction sets But with many aspects in common Early computers

### MIPS Assembly Language

MIPS Assembly Language Chapter 15 S. Dandamudi Outline MIPS architecture Registers Addressing modes MIPS instruction set Instruction format Data transfer instructions Arithmetic instructions Logical/shift/rotate/compare

### ENGN1640: Design of Computing Systems Topic 03: Instruction Set Architecture Design

ENGN1640: Design of Computing Systems Topic 03: Instruction Set Architecture Design Professor Sherief Reda http://scale.engin.brown.edu School of Engineering Brown University Spring 2014 Sources: Computer

### Computer Architecture. Chapter 2-2. Instructions: Language of the Computer

Computer Architecture Chapter 2-2 Instructions: Language of the Computer 1 Procedures A major program structuring mechanism Calling & returning from a procedure requires a protocol. The protocol is a sequence

### QtSPIM and MARS : MIPS Simulators

QtSPIM and MARS : MIPS Simulators Learning MIPS & SPIM MIPS assembly is a low-level programming language The best way to learn any programming language is to write code We will get you started by going

### Computer Organization and Structure. Bing-Yu Chen National Taiwan University

Computer Organization and Structure Bing-Yu Chen National Taiwan University Instructions: Language of the Computer Operations and Operands of the Computer Hardware Signed and Unsigned Numbers Representing

### EE 361 University of Hawaii Fall

C functions Road Map Computation flow Implementation using MIPS instructions Useful new instructions Addressing modes Stack data structure 1 EE 361 University of Hawaii Implementation of C functions and

### Compiling Techniques

Lecture 10: An Introduction to MIPS assembly 18 October 2016 Table of contents 1 Overview 2 3 Assembly program template.data Data segment: constant and variable definitions go here (including statically

### MIPS ISA and MIPS Assembly. CS301 Prof. Szajda

MIPS ISA and MIPS Assembly CS301 Prof. Szajda Administrative HW #2 due Wednesday (9/11) at 5pm Lab #2 due Friday (9/13) 1:30pm Read Appendix B5, B6, B.9 and Chapter 2.5-2.9 (if you have not already done

### EEC 581 Computer Architecture Lecture 1 Review MIPS

EEC 581 Computer Architecture Lecture 1 Review MIPS 1 Supercomputing: Suddenly Fancy 2 1 Instructions: Language of the Machine More primitive than higher level languages e.g., no sophisticated control

### Previously. CSE 2021: Computer Organization. Memory Organization. The Load/Store Family (1) 5/26/2011. Used to transfer data to/from DRAM.

CSE 2021: Computer Organization Lecture-4 Code Translation-2 Memory, Data transfer instructions, Data segment,, Procedures, Stack Shakil M. Khan (adapted from Profs. Roumani & Asif) Previously Registers

### CS3350B Computer Architecture

CS3350B Computer Architecture Winter 2015 Lecture 4.1: MIPS ISA: Introduction Marc Moreno Maza www.csd.uwo.ca/courses/cs3350b [Adapted d from lectures on Computer Organization and Design, Patterson & Hennessy,

### CS3350B Computer Architecture MIPS Introduction

CS3350B Computer Architecture MIPS Introduction Marc Moreno Maza http://www.csd.uwo.ca/~moreno/cs3350_moreno/index.html Department of Computer Science University of Western Ontario, Canada Thursday January

### Functions in MIPS. Functions in MIPS 1

Functions in MIPS We ll talk about the 3 steps in handling function calls: 1. The program s flow of control must be changed. 2. Arguments and return values are passed back and forth. 3. Local variables

### 1 5. Addressing Modes COMP2611 Fall 2015 Instruction: Language of the Computer

1 5. Addressing Modes MIPS Addressing Modes 2 Addressing takes care of where to find data instruction We have seen, so far three addressing modes of MIPS (to find data): 1. Immediate addressing: provides

### Instruction Set Architectures (4)

Computer Architecture Week 06 Instruction Set Architectures (4) College of Information Science and Engineering Ritsumeikan University subroutines functions, procedures remember the next instruction s address

### Stored Program Concept. Instructions: Characteristics of Instruction Set. Architecture Specification. Example of multiple operands

Stored Program Concept Instructions: Instructions are bits Programs are stored in memory to be read or written just like data Processor Memory memory for data, programs, compilers, editors, etc. Fetch

### 4.2: MIPS function calls

4.2: MIPS function calls Topics: Nested function calls: poly() and pow() Saving the return address (\$31) Saving temporary registers Looking at activation records on the stack Introduction: In CSc 256 lectures,

### ENCM 369 Winter 2013: Reference Material for Midterm #2 page 1 of 5

ENCM 369 Winter 2013: Reference Material for Midterm #2 page 1 of 5 MIPS/SPIM General Purpose Registers Powers of Two 0 \$zero all bits are zero 16 \$s0 local variable 1 \$at assembler temporary 17 \$s1 local

### ECE232: Hardware Organization and Design. Computer Organization - Previously covered

ECE232: Hardware Organization and Design Part 6: MIPS Instructions II http://www.ecs.umass.edu/ece/ece232/ Adapted from Computer Organization and Design, Patterson & Hennessy, UCB Computer Organization

### Systems Architecture I

Systems Architecture I Topics Assemblers, Linkers, and Loaders * Alternative Instruction Sets ** *This lecture was derived from material in the text (sec. 3.8-3.9). **This lecture was derived from material

### MIPS (SPIM) Assembler Syntax

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

### TSK3000A - Generic Instructions

TSK3000A - Generic Instructions Frozen Content Modified by Admin on Sep 13, 2017 Using the core set of assembly language instructions for the TSK3000A as building blocks, a number of generic instructions

### Prof. Kavita Bala and Prof. Hakim Weatherspoon CS 3410, Spring 2014 Computer Science Cornell University. See P&H 2.8 and 2.12, and A.

Prof. Kavita Bala and Prof. Hakim Weatherspoon CS 3410, Spring 2014 Computer Science Cornell University See P&H 2.8 and 2.12, and A.5 6 compute jump/branch targets memory PC +4 new pc Instruction Fetch

### CS3350B Computer Architecture MIPS Procedures and Compilation

CS3350B Computer Architecture MIPS Procedures and Compilation Marc Moreno Maza http://www.csd.uwo.ca/~moreno/cs3350_moreno/index.html Department of Computer Science University of Western Ontario, Canada

### Computer Systems and Networks

LECTURE 16: MIPS (11 AND 12) Computer Systems and Networks Dr. Pallipuram (vpallipuramkrishnamani@pacific.edu) University of the Pacific Deadline Lab 11 is open: DUE 1 st NOV 5 AM Lab 12 is open: DUE 8

### Lectures 5. Announcements: Today: Oops in Strings/pointers (example from last time) Functions in MIPS

Lectures 5 Announcements: Today: Oops in Strings/pointers (example from last time) Functions in MIPS 1 OOPS - What does this C code do? int foo(char *s) { int L = 0; while (*s++) { ++L; } return L; } 2

### Quick Review. lw \$t0, 4(\$a0) Registers x Memory. \$a0 is simply another name for register 4 \$t0 is another name for register (green sheet)

CSE378 Lecture 3 Today: Finish up memory Control-flow (branches) in MIPS if/then loops case/switch (maybe) Start: Array Indexing vs. Pointers In particular pointer arithmetic String representation 1 Quick

### COMPSCI 313 S Computer Organization. 7 MIPS Instruction Set

COMPSCI 313 S2 2018 Computer Organization 7 MIPS Instruction Set Agenda & Reading MIPS instruction set MIPS I-format instructions MIPS R-format instructions 2 7.1 MIPS Instruction Set MIPS Instruction

### MIPS Assembly (Functions)

ECPE 170 Jeff Shafer University of the Pacific MIPS Assembly (Functions) 2 Lab Schedule This Week Activities Lab work time MIPS functions MIPS Random Number Generator Lab 11 Assignments Due Due by Apr

### MIPS Assembly Language Programming

MIPS Assembly Language Programming COE 308 Computer Architecture Prof. Muhamed Mudawar College of Computer Sciences and Engineering King Fahd University of Petroleum and Minerals Presentation Outline Assembly

### MIPS Assembly Language Programming

MIPS Assembly Language Programming ICS 233 Computer Architecture and Assembly Language Dr. Aiman El-Maleh College of Computer Sciences and Engineering King Fahd University of Petroleum and Minerals [Adapted

### University of California at Santa Barbara. ECE 154A Introduction to Computer Architecture. Quiz #1. October 30 th, Name (Last, First)

University of California at Santa Barbara ECE 154A Introduction to Computer Architecture Quiz #1 October 30 th, 2012 Name (Last, First) All grades will be posted on the website as a single spreadsheet

### Instructions: MIPS arithmetic. MIPS arithmetic. Chapter 3 : MIPS Downloaded from:

Instructions: Chapter 3 : MIPS Downloaded from: http://www.cs.umr.edu/~bsiever/cs234/ Language of the Machine More primitive than higher level languages e.g., no sophisticated control flow Very restrictive

### Lecture 7: MIPS Functions Part 2. Nested Function Calls. Lecture 7: Character and String Operations. SPIM Syscalls. Recursive Functions

Part Part Part What if we need to call a function inside of a function? Will this work? int twofun(int a, int b) { int res; res = addfun(a, b) a / ; return res; } twofun: addi \$sp, \$sp, -4 sw \$s0, 0(\$sp)

### CSE Lecture In Class Example Handout

CSE 30321 Lecture 07-08 In Class Example Handout Part A: J-Type Example: If you look in your book at the syntax for j (an unconditional jump instruction), you see something like: e.g. j addr would seemingly

### MIPS Reference Guide

MIPS Reference Guide Free at PushingButtons.net 2 Table of Contents I. Data Registers 3 II. Instruction Register Formats 4 III. MIPS Instruction Set 5 IV. MIPS Instruction Set (Extended) 6 V. SPIM Programming

### Subroutines. int main() { int i, j; i = 5; j = celtokel(i); i = j; return 0;}

Subroutines Also called procedures or functions Example C code: int main() { int i, j; i = 5; j = celtokel(i); i = j; return 0;} // subroutine converts Celsius to kelvin int celtokel(int i) { return (i

### Machine Instructions - II. Hwansoo Han

Machine Instructions - II Hwansoo Han Conditional Operations Instructions for making decisions Alter the control flow - change the next instruction to be executed Branch to a labeled instruction if a condition

### Introduction to MIPS Processor

Introduction to MIPS Processor The processor we will be considering in this tutorial is the MIPS processor. The MIPS processor, designed in 1984 by researchers at Stanford University, is a RISC (Reduced

### Overview. Introduction to the MIPS ISA. MIPS ISA Overview. Overview (2)

Introduction to the MIPS ISA Overview Remember that the machine only understands very basic instructions (machine instructions) It is the compiler s job to translate your high-level (e.g. C program) into

### CS 316: Procedure Calls/Pipelining

CS 316: Procedure Calls/Pipelining Kavita Bala Fall 2007 Computer Science Cornell University Announcements PA 3 IS out today Lectures on it this Fri and next Tue/Thu Due on the Friday after Fall break

### CISC 662 Graduate Computer Architecture. Lecture 4 - ISA

CISC 662 Graduate Computer Architecture Lecture 4 - ISA Michela Taufer http://www.cis.udel.edu/~taufer/courses Powerpoint Lecture Notes from John Hennessy and David Patterson s: Computer Architecture,