1 Chapter 3: Instructions CS 447 Jason D. Bakos. 2 Assembly Language Instructions We’re going to use the MIPS R2000 instruction set for the projects in.

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

Goal: Write Programs in Assembly
Lecture 5: MIPS Instruction Set
CS/COE0447 Computer Organization & Assembly Language
ECE 232 L6.Assemb.1 Adapted from Patterson 97 ©UCBCopyright 1998 Morgan Kaufmann Publishers ECE 232 Hardware Organization and Design Lecture 6 MIPS Assembly.
10/9: Lecture Topics Starting a Program Exercise 3.2 from H+P Review of Assembly Language RISC vs. CISC.
CS1104 – Computer Organization PART 2: Computer Architecture Lecture 5 MIPS ISA & Assembly Language Programming.
Chapter 2 Instructions: Language of the Computer
1 Nested Procedures Procedures that don't call others are called leaf procedures, procedures that call others are called nested procedures. Problems may.
The University of Adelaide, School of Computer Science
Comp Sci instruction encoding 1 Instruction Encoding MIPS machine language Binary encoding of instructions MIPS instruction = 32 bits Three instruction.
Assembly Language II CPSC 321 Andreas Klappenecker.
MIPS Assembly Language I Computer Architecture CPSC 321 Andreas Klappenecker.
ENEE350 Spring07 1 Ankur Srivastava University of Maryland, College Park Adapted from Computer Organization and Design, Patterson & Hennessy, © 2005.”
Computer Architecture CPSC 321 E. J. Kim. Overview Logical Instructions Shifts.
Chapter 3: Instructions
Computer Structure - The Instruction Set (2) Goal: Implement Functions in Assembly  When executing a procedure (function in C) the program must follow.
S. Barua – CPSC 440 CHAPTER 2 INSTRUCTIONS: LANGUAGE OF THE COMPUTER Goals – To get familiar with.
1 Lecture 2: MIPS Instruction Set Today’s topic:  MIPS instructions Reminder: sign up for the mailing list cs3810 Reminder: set up your CADE accounts.
RISC Concepts, MIPS ISA and the Mini–MIPS project
Lecture 5 Sept 14 Goals: Chapter 2 continued MIPS assembly language instruction formats translating c into MIPS - examples.
9/29: Lecture Topics Memory –Addressing (naming) –Address space sizing Data transfer instructions –load/store on arrays on arrays with variable indices.
IT253: Computer Organization Lecture 5: Assembly Language and an Introduction to MIPS Tonga Institute of Higher Education.
CSCI 136 Lab 1: 135 Review.
Chapter 10 The Assembly Process. What Assemblers Do Translates assembly language into machine code. Assigns addresses to all symbolic labels (variables.
April 23, 2001Systems Architecture I1 Systems Architecture I (CS ) Lecture 9: Assemblers, Linkers, and Loaders * Jeremy R. Johnson Mon. April 23,
Lecture 4: MIPS Instruction Set
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.
Computer Architecture CSE 3322 Lecture 4 Assignment: 2.4.1, 2.4.4, 2.6.1, , Due 2/10/09
MIPS Assembly Language Chapter 13 S. Dandamudi To be used with S. Dandamudi, “Introduction to Assembly Language Programming,” Second Edition, Springer,
Chapter 2 — Instructions: Language of the Computer — 1 Conditional Operations Branch to a labeled instruction if a condition is true – Otherwise, continue.
MIPS Assembly Language Chapter 15 S. Dandamudi To be used with S. Dandamudi, “Fundamentals of Computer Organization and Design,” Springer, 2003.
CDA 3101 Spring 2016 Introduction to Computer Organization
Lecture 16: 10/29/2002CS170 Fall CS170 Computer Organization and Architecture I Ayman Abdel-Hamid Department of Computer Science Old Dominion University.
CSCE 212 Chapter 2: Instruction Set Architecture Instructor: Jason D. Bakos.
Instructor: Prof. Hany H Ammar, LCSEE, WVU
Computer Architecture Instruction Set Architecture
CS2100 Computer Organisation
Computer Organization and Design Instruction Sets - 2
Lecture 4: MIPS Instruction Set
ELEN 468 Advanced Logic Design
Computer Organization and Design Instruction Sets - 2
RISC Concepts, MIPS ISA Logic Design Tutorial 8.
32-bit MIPS ISA.
ENGR 3410 – Computer Architecture Mark L. Chang Fall 2006
Computer Organization and Design Instruction Sets
CSCE 212 Chapter 2: Instruction Set Architecture
Instructions - Type and Format
Lecture 4: MIPS Instruction Set
MPIS Instructions Functionalities of instructions Instruction format
Computer Architecture & Operations I
The University of Adelaide, School of Computer Science
ECE232: Hardware Organization and Design
Instruction encoding The ISA defines Format = Encoding
Review.
Part II Instruction-Set Architecture
Computer Instructions
Flow of Control -- Conditional branch instructions
Instruction encoding The ISA defines Format = Encoding
COMS 361 Computer Organization
UCSD ECE 111 Prof. Farinaz Koushanfar Fall 2018
Instruction encoding The ISA defines Format = Encoding
Flow of Control -- Conditional branch instructions
Instruction encoding The ISA defines Format = Encoding
CS352H Computer Systems Architecture
Reduced Instruction Set Computer (RISC)
MIPS Arithmetic and Logic Instructions
9/27: Lecture Topics Memory Data transfer instructions
MIPS Arithmetic and Logic Instructions
Presentation transcript:

1 Chapter 3: Instructions CS 447 Jason D. Bakos

2 Assembly Language Instructions We’re going to use the MIPS R2000 instruction set for the projects in this course Review: Assembly language instructions are English words that represent binary machine language instructions

3 Arithmetic/Logical Instructions Arithmetic instructions are composed of an operation and three registers – –There are bit general-purpose integer registers that we can use (R0 is hardwired to value 0 for A/L operands) –Ex: add $1, $2, $3 When writing assembly language programs, comments can be added after any instruction by using the ‘#’ character Some architectures only use 2 registers –The result is stored in the first operand register –Some of our instructions will use this convention Appendix A in the textbook lists all

4 Immediate Arithmetic/Logical Instructions Most arithmetic/logical instructions have an “immediate” version –Immediate instructions have an ‘i’ at the end of the instruction name –Immediate instructions allow us to specify an immediate/constant/literal in lieu of a register operand –Ex: add $1, $2, 16 –We only have 16-bits for the immediate, so we can only represent 2 16 unique values –Use decimal numbers for the immediate value in the assembly-language instruction

5 A/R Instructions MIPS R2000 A/L-instructions (complete) –add, addu, addi, addiu –and, andi –div, divu (two registers) –mult, multu (two registers) –nor –or, ori –sll, sllv, sra, srav, srl, srlv –sub, subu –xor, xori

6 Pseudoinstructions Pseudoinstructions are assembled into more than 1 machine instruction –There’s no real machine instruction for them –Ex. abs rdest, rsrc –Assembles into three instructions move the contents of rsrc into rdest if rdest is greater than 0, skip over the next instruction –We haven’t covered conditional branches yet subtract rdest from 0 –Appendix A specifies which are pseudoinstructions

7 Design Considerations Making most arithmetic instructions have 3 operands simplifies the hardware –This is a design decision –Having a variable number of operands would greatly complicate the hardware Limiting ourselves to 32 registers is also a design decision to keep things on the processor die smaller –Influences clock cycle time –Gives us more real estate for other things on our core Less registers, less decoding logic, etc.

8 Registers MIPS assembly language also has symbolic names for the registers –$0 => constant 0 –$1 => $at (reserved for assembler) –$2,$3 => $v0,$v1 (expression evaluation and results of a function) –$4-$7 => $a0-$a3 (arguments 1-4) –$8-$15 => $t0-$t7 (temporary values) Used when evaluating expressions that contain more than two operands (partial solutions) Not preserved across function calls –$16-$23 => $s0->$s7 (for local variables, preserved across function calls) –$24, $25 => $t8, $t9 (more temps) –$26,$27 => $k0, $k1 (reserved for OS kernel) –$28 => $gp (pointer to global area) –$29 => $sp (stack pointer) –$30 => $fp (frame pointer) –$31 => $ra (return address, for branch-and-links)

9 Memory and Load/Store Instructions As we’ve already seen, a processor can only use data stored in its registers as operands and targets for computation Typically, before computation can be performed, data must be loaded from main memory After the computation is complete, the results must be stored back to main memory

10 Memory Computer memory is byte-addressed but the MIPS architecture requires alignment of loads and stores on the 32-bit (4 byte/word) boundary –This means that all memory references must be an even multiple of 4 When addressing 4-byte words, you need to provide the address of the lowest-addressed byte in the word

11 Load/Store Instructions Most commonly used: –lw, sw, lh, sh, lb, sb, la Use: –lw, address –address can be represented as: symbolic address (that you declare in SPIM) symbolic address with register index decimal_offset($basereg) –This is the way that the instruction is translated –loads/stores from contents of $basereg+decimal_offset

12 Load/Store Instructions SPIM treats loads and stores with symbolic addresses as pseudoinstructions –loads the address of the data segment as an immediate into $1 lui $1, 4097 –data starts at hex address –If an index register is provided, adds the contents of the index reg to $1 addu $1, $1, rindex –loads 0($1) into rdest lw rdest, offset_of_variable($1) This is an example of base-displacement addressing This is why R1 is reserved when you write your programs

13 Load/Store Instructions When loading or storing halfwords and bytes, the address points to a aligned word –The halfword would be the LOWER (least significant) halfword of the word that the address is pointing to –The byte world be the LOWEST (least significant) byte of the word being that the address is pointing to

14 Constant-Manipulating Instructions lui rt, imm –Load the immediate imm into the upper halfword of register rt –The lower bits are set to 0 li rt, imm –Load the imm into the lower halfword of register rt –The upper bits are set to 0

15 Encoding Instructions The MIPS architecture has a 32-bit binary instruction format for each class of instruction –A/L, constant manip, comparison, branch, jump, load/store, data movement, floating-point Even though we’ve only covered 3 of these classes, let’s look at how we encode the instructions we’ve learned…

16 Encoding/Translating A/L Instructions First (most significant, left-most) 6- bits of ALL instructions is the op- code –The opcode defines the instruction –Doesn’t this only give us 2 6 =64 different instructions? Yes! But all A/L instructions, excluding the ones which have immediates, has an opcode of 0 but has a 6-bit field at the end of the instruction that specifies the operation

17 Encoding/Translating A/L Instructions Non-immediate A/L instructions: –6 bits – opcode (usually 0) –5 bits – rs (operand 1) –5 bits – rt (operand 2) –5 bits – rd (destination) –5 bits – 0’s or shift amount –6 bits – operation code

18 Encoding/Translating A/L Instructions Immediate A/L instructions –6 bits – opcode (now unique) –5 bits – rs (operand 1) –5 bits – rt (destination) –16 bits – immediate (understood to be 0- extended)

19 Encoding/Translating Load/Store Instructions 6 bits – opcode 5 bits – rs (base register) 5 bits – rt (load from/store to) –Sometimes the whole register isn’t used Half words and bytes 16 bits – offset

20 Encoding/Translating Constant-Manip. Instructions 6 bits – opcode 5 bits – 0’s 5 bits – rt dest. register –Half of this register will be assigned 0’s 16 bits – immediate

21 Examples Let’s compile the following C++ code segment into assembly code: –z=(a*b)+(c/d)-(e+f*g); –lw $s0,a lw $s1,b mult $s0,$s1 mflo $t0# new instruction lw $s0,c lw $s1,d div $s0,$s1 mflo $t1 add $t0,$t0,$t1 lw $s0,e lw $s1,f lw $s2,g mult $s1,$s2 mflo $t1 add $t1,$s0,$t1 sub $t0,$t0,$t1 sw $t0,z

22 Examples Note: There were many ways we could have compiled the C++ statement Now let’s assemble the first three instructions to machine code –Assume the variables are all stored as words and are stored sequencially, starting with a, from the start of the data segment…

23 Examples lw $s0,a –We know s0 is $16 –There are a few different ways we can do this, too… –First, we need to convert this instruction to a small series of instructions… –lui $1,4097# 4097 is 1001 in hex lw 16,0($1)# 0 offset because a is first var … => 3C => 8C100000

24 Examples mult $s0, $s1 – =>

25 Branch/Jump Instructions Branch and jump instructions are needed for program control –if-statements (conditionals) –loops –procedure calls Most common: –b -- unconditional branch label is a memory address (we can be symbolic ones, of course) –beq, bgez, bgezal, bgtz, blez, etc. Conditional branches, where we’re comparing a register to 0 or two registers to determine if we’re going to branch or not Also have al (and-link) variants, that link a return address (instruction following branch) into $31 so we can return Branch targets are 16-bit immediate offset –offset in words… it is shifted to the left 2 bits to get byte length

26 Branch/Jump Instructions –j, jal Unconditionally branches to a 26-bit pseudodirect address (not offset) –jalr, jr Unconditionally branches to an address stored in a register

27 Encoding/Translating Branch/Jump Instructions See Appendix A –These are very similar to the encoding we covered before

28 Data Movement and Comparison Instructions and Their Encoding I’m going to leave the study of these instructions (from Appendix A) up to you as an exercise!

29 Examples if ((a>b)&&(c=d)) e=0; else e=f; lw $s0,a lw $s1,b bgt $s0,$s1,next0 b nope next0:lw $s0,c lw $s1,d beq $s0,$s1,yup nope:lw $s0,f sw $s0,e b out yup:xor $s0,$s0,$s0 sw $s0,e out:…

30 Examples Again, there are many other ways we could have tackled this… You will eventually come up with your own strategies for “compiling” the types of constructs you want to perform…

31 Examples How about a for loop? for (i=0;i<a;i++) b[i]=i; lw $s0,a xor $s1,$s1,$s1 loop0:blt $s1,$s0,loop1 b out sll $s2,S1,2 loop1:sw $s1,b($s2) addi $s1,$s1,1 b loop0 out:…

32 Examples How about a pretest while loop? while (a<b) { a++; } lw $s0,a lw $s1,b loop0:blt $s0,$s1,loop1 b out loop1:addi $s0,Ss0,1 sw $s0,a b loop0 out:…

33 Examples How about a posttest while loop? do { a++; } while (a<b); lw $s0,a lw $s1,b loop0:addi $s0,$s0,1 sw $s0,a blt $s0,$s1,loop0 …

34 Procedure Calls How about a procedure call? –The full-blown C/Pascal recursive procedure call convention is beyond the scope of this class, so we’ll skip it for now… –This is described in detail in Appendix A You can arbitrarily implement your own procedure call convention…

35 Procedure Calls Say we want to write a procedure that computes the factorial of a number, like this: int factorial (int val) { int temp=val; while (val) temp*=(--val); return temp; }

36 Procedure Calls Let’s adopt the following simple convention: –We’ll pass the arguments through $a0-$a3 Only allows for up to 4 arguments –We’ll set our return value in $v0 –The return address will be stored in $ra This limits us to 1-level of procedure calls –We’ll assume the callee (procedure) will save registers $s0-$s7 starting at memory address FF when it’s called, and restore the registers before it returns This may not be necessary for all procedures

37 Procedure Calls So here’s our procedure… factorial:lui $t1,0xFF00 sw $s0,0($t1) sw $s1,4($t1) … sw $s7,28($t1) move $s0,$a0# new instruction move $s1,$a0 loop0:bgtz $s0,loop1 b out loop1:mult $s0,$s1 mflo $s1 subi $s0,$s0,1 b loop0 out:move $v0,$s1 lw $s0,0($t1)# load back registers … jr $31

38 Procedure Calls In order to call our procedure… –load a value into $a0 –bal factorial –look in $v0 for the result!

39 I/O Doing I/O with SPIM is also described in Appendix A, but we’re going to use the system calls that are set up for us to do I/O…

40 I/O SPIM provides some operating system services through the syscall instruction To use the system calls: –load system call code (from pg. a49) into $v0 and argument into $a0… –return values in $v0 (or $f0 for fp results)

41 Example I/O str:.asciiz“the answer = “.text li$v0,4 la$a0, str syscall li$v0,1 la$a0,5 syscall (Refer to page A-49)