COMP MIPS instructions 3 Feb. 10, 2016
|
|
- Derick Collins
- 1 years ago
- Views:
Transcription
1 In the past two lectures, we discussed MIPS operations on integers. Today we will consider a few data structures that you are familiar with, namely arrays and strings, and discuss how to implement them in MIPS. Arrays Suppose we wish to declare and use an array of N integers. How would we represent this array in MIPS? If we were programming in C, we might let the array be a[ ]. Let the address of the first element of the array be kept in one of the registers, say $s0. This address is called the base address of the array. To access an element of array, we need to specify the address of that element relative to the base address, i.e. the offset. For example, consider the C instructions: a[12] = a[10]; In MIPS, we cannot transfer data directly from one location in Memory to another. Instead, we need to pass the data through a register. Here might be the corresponding MIPS instructions: lw $t1, 40($s0) sw $t1, 48($s0) The offsets from the base address are 40 and 48 for a[10] and a[12] respectively. Why? We need four bytes for each word, so an offset of 10 words is an offset of 40 bytes and an offset of 12 words is an offset of 48 bytes. Another example is the C instruction, m = a[i]; Suppose the integer variable m is stored in register $s1 and integer index i is stored in register $s2. We multiply the contents of $s2 by 4 to get the offset, and then we add the offset to the base address which we ll assume is in $s0 as in the above example. Note that we compute the offset by multiplying i by 4 by using the sll instruction, which is simpler than having to perform a general multiplication. (We will see how to perform multiplication in an upcoming lecture.) sll $t0, $s2, 2 add $t0, $s0, $t0 lw $s1, 0($t0) Strings In the C programming language (COMP 206), a variable of type char uses one byte (http: //www.asciitable.com). Thus, each character in a string is stored in one byte. Previously, we saw the instructions lw and sw which load a word from Memory or store a word to Memory, respectively. There are similar instructions for single bytes. lb loads a byte, and sb stores a byte. These functions are of I-format. Again, we specify the address of the byte with a base address plus an offset. The offset is a signed number. last updated: 17 th Feb, lecture notes c Michael Langer
2 lb $s2, 3( $s1 ) sb $s2, -2( $s1 ) lb takes one byte from memory and puts it into a register. The upper 24 bits of the register are sign extended i.e. filled with whatever value is in the most significant bit (MSB) of that byte. There is also an unsigned version of load byte, namely lbu, which fills the upper 24 bits with 0 s (regardless of the MSB). sb copies the lower 8 bits of a register into some byte in memory. This instruction ignores the upper 24 bits of the word in the register. Example: How to calculate the length of a character string? Consider the following C instructions that compute the length of a string. In C, a string is a sequence of bytes, terminated by the ASCII NULL character which is denoted \0 and which has byte value 0x00. char *str; // Declare a pointer to a string. // str is an address (a 32 bit number). int ct; str = "I love COMP 273"; while ( *(str + ct)!= \0 ){ ct++; } The variable str is a pointer (or reference ) and so its value is an address, which is just an unsigned integer (32 bits). The fancy instruction above then adds an offset ct to this address. The * operator dereferences that address, which means that it returns the content that is stored at that address. If you are taking COMP 206 now, then you will learn about dereferencing soon. (Joseph told me so.) Here s is MIPS code that does roughly the same thing as the while loop part of the above code. (Let s not deal with the initialization part of the code that comes before the while loop. For now, just accept that the first instruction la loads the address of the string str into register $s0. Also, assume ct is in register $s1.) la $s0, str # pseudoinstruction (load address) add $s1, $zero, $zero # initialize ct, $s1 = 0. loop: add $t0, $s0, $s1 # address of byte to examine next lb $t1, 0( $t0 ) # load that byte to get *(s + ct) beq $t1, $zero, exit # branch if *(s + ct) == \0 addi $s1, $s1, 1 # increment ct j loop exit: Register $t1 holds the ct th char (a byte) and this byte is stored in the lower 8 bits of the register. Note also that I have used $t registers for temporary values that do not get assigned to variables in the C program, and I have used $s registers for variables. I didn t need to do this, but I find it cleaner to do it. last updated: 17 th Feb, lecture notes c Michael Langer
3 Assembler directives We have seen many MIPS instructions. We now would like to put them together and write programs. To define a program, we need certain special instructions that specify where the program begins, etc. We also need instructions for declaring variables and initializing these variables. Such instructions are called assembler directives, since they direct the assembler on what (data) to put where (address). Let s look at an example. Recall the MIPS code that computes the length of a string. We said that the string was stored somewhere in Memory and that the address of the string was contained in some register. But we didn t say how the string got there. Below is some code program that defines a string in MIPS Memory and that counts the number of characters in the string. The program begins with several assembler directives (.data,.asciiz,... ) followed by a main program for computing string length. The.data directive says that the program is about to declare data that should be put into the data segment of Memory. Next, the instruction label str just defines an address that you can use by name when you are programming. It allows you to refer a data item (in this case, a string). We ll see how this is done later. In particular, the line has an.asciiz directive which declares a string, COMP 273. When the program below uses the label str, the assembler translates this label into a number. This number can be either an offset value which is stored in the immediate field (16 bits) of I-format instruction or a 26 bit offset which in a J format instruction. The.text directive says that the instructions that follow should be put in the instruction ( text ) segment of memory. The.align 2 directive puts the instruction at an address whose lower 2 bits are 00. The.globl main directive declares the instructions that follow are your program. The first line of your program is labelled main..data # Tells assembler to put the following # ABOVE the static data part of Memory. # (see remark at bottom of this page) str:.asciiz "COMP 273" # Terminates string with NULL character..text # Tells the assembler to put following # in the instruction segment of Memory..align 2 # Word align (2^2).globl main # Assembler expects program to have # a "main" label, where program starts main: la $s0, str # pseudoinstruction (load address) # (INSERT HERE THE MIPS CODE ON PREVIOUS PAGE) The address of the string is loaded into register using the pseudoinstruction la which stands for load address. MARS translates this instruction into lui $s0, 4097 Note that (4097) 10 = 0x1001, and so the address is 0x which is the beginning address of the user data segment. (Actually there is a small static part of the data segment below this which starts at address 0x You can see this in MARS.) last updated: 17 th Feb, lecture notes c Michael Langer
4 Here are some more assembler directives that you may need to use:.word assigns 32-bit values.byte initializes single bytes.space reserves a number of bytes For example, y0:.word -14 b:.byte 24, 62, 1 arr:.space 60 y1:.word 17 declares labels y0, b, arr, y1 which stand for addresses that you can use in your program. You would not use these labels in branch instructions, since these addresses are in the data segment, not in the text (instruction) segment. Rather, you use them as variables. The variable y0 is initialized to have value -14. The variable b is an array of 3 bytes. The variable arr is pointer to the start of 60 consecutive bytes of Memory. This region can be used in a flexible way. For example, it could be used to hold an array of 15 integers. Suppose we wanted to swap the values that are referenced by y0 and y1. How would you do this? If you are programming in C or in Java, you use a temporary variable. tmp = y0; y0 = y1; y1 = tmp; Suppose y0 and y1 are in registers $s0 and $s1 respectively. You could use the pseudoinstruction move, or move $t0, $s0 # same as "add $t0, $s0, $zero" move $s0, $s1 move $s1, $t0 However, if the variables are in Memory rather than in registers, then you would first need to load them into Memory, do the swap, and then store them back in Memory. Alternatively, you could just do it like this. la $t0, y0 # load addresses of variables to swap la $t1, y1 # assuming they are labelled y0 and y1 lw $s0, 0($t0) # load contents into registers lw $s1, 0($t1) sw $s1, 0($t0) # store in opposite position sw $s0, 0($t1) last updated: 17 th Feb, lecture notes c Michael Langer
5 System Calls We have seen how data can be defined using assembler directives. It is often more useful to use input/output (I/O) to read data into a program at runtime, and also to write e.g. to a console that a user can read, or to a file. Here I will describe how to use the console for reading and writing. There is a MIPS instruction syscall which tells the MIPS kernel/os that you want to do I/O or some other operation that requires the operating system, such as exiting the program. You need to specify a parameter to distinguish between several different system calls. You use the register $2 for this, also known as $v0. To print to the console, use values 1,2,3, 4 which are for the case of int, float, double, or string, respectively. To read from the console, use values 5,6,7,8 for int, float, double, or string, respectively. When you are reading or printing, you need to specify which register(s) hold the values/addresses you are reading from/to. There is no need to memorize this stuff. Consult the documentation on MARS. Here is an example of how to print a string to the console. la $a0, str # la is a pseudoinstruction ("load address") li $v0, 4 # code for printing a string is 4 syscall [MODIFIED Feb 17. The notes I originally posted contained a mistake.] Here is an example of how to read a string from console. You need to specify that you want to read a string. You need to specify where the string will be put in Memory. You need to specify a buffer size for the kernel to use to read the string. (See Assignment 2 Part 4.) Suppose the maximum buffer size for reading a string is specified by a integer value which is stored in the data segment at label sizebuffer as in Assignment 2. Here is the code for reading a string. li $v0, 8 # code for reading string is 8. add $a0, $zero, $s1 # suppose $s1 specifies address # where string will start la $t0, sizebuffer # specifies a buffer size for reading string. lw $a1, 0($t0) # load that buffer size. syscall In the slides I then discussed Assignment 2. last updated: 17 th Feb, lecture notes c Michael Langer
High level language programs versus Machine code
High level language programs versus Machine code You all have experience programming in a high level language. You know that when you write a program in a language such as C or Java, the program is nothing
CSE 378 Quiz Section #2 Coding in MIPS Assembly
Let s translate this C function into assembly: CSE 378 Quiz Section #2 Coding in MIPS Assembly int arr[10] = {1,2,3,4,5,6,7,8,9,10; int compute_smth() { int i, sum=0; for (i = 0; i < 10; i++) { printf(
MIPS Hello World. MIPS Assembly 1
MIPS Hello World MIPS Assembly 1 # Hello, World!.data ## Data declaration section ## String to be printed: out_string:.asciiz "\nhello, World!\n".text ## Assembly language instructions go in text segment
MIPS Assembly Code Layout
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 through a few example programs and
ECE 473 Computer Architecture and Organization Lab 4: MIPS Assembly Programming Due: Thursday, October 10 (100 points)
ECE 473 Computer Architecture and Organization Lab 4: MIPS Assembly Programming Due: Thursday, October 10 (100 points) Objectives: Get familiar with MIPS instructions Assemble, execute and debug MIPS assembly
Some Samples of MIPS Assembly Language. Lecture for CPSC 5155 Edward Bosworth, Ph.D. Computer Science Department Columbus State University
Some Samples of MIPS Assembly Language Lecture for CPSC 5155 Edward Bosworth, Ph.D. Computer Science Department Columbus State University Structure of This Lecture This lecture will be built around a number
Lecture 4. Announcements:
Announcements: Lecture 4 HW1 posted on Saturday morning. We gave a little over a week. We are going to discuss relevant material over the next two lectures. Lab1 posted. But if you start doing it, you
System Programming. The SPIM S20 MIPS Simulator
Sep 06 Hugo Marcondes (http://www.lisha.ufsc.br) 1 System Programming The SPIM S MIPS Simulator Hugo Marcondes hugom@lisha.ufsc.br http://www.lisha.ufsc.br/~hugom Sep 06 Sep 06 Hugo Marcondes (http://www.lisha.ufsc.br)
Lecture 5: MIPS Examples
Lecture 5: MIPS Examples Today s topics: the compilation process full example sort in C Reminder: 2 nd assignment will be posted later today 1 Dealing with Characters Instructions are also provided to
Introduction to MIPS Assembly Programming
1 / 26 Introduction to MIPS Assembly Programming January 23 25, 2013 2 / 26 Outline Overview of assembly programming MARS tutorial MIPS assembly syntax Role of pseudocode Some simple instructions Integer
The Program Counter. Erik Jonsson School of Engineering and Computer Science. The University of Texas at Dallas
1 The Program Counter PC = 0040003c EPC = 00000000 Cause = 00000000 BadVAddr= 00000000 Status = 3000ff10 HI = 00000000 LO = 00000000 General Registers R0 (r0) = 00000000 R8 (t0) = 00000000 R16 (s0) = 00000000
Computer Systems Architecture
Computer Systems Architecture http://cs.nott.ac.uk/ txa/g51csa/ Thorsten Altenkirch and Liyang Hu School of Computer Science and IT University of Nottingham Lecture 04: Machine Code, Data Transfer and
Mips Code Examples Peter Rounce
Mips Code Examples Peter Rounce P.Rounce@cs.ucl.ac.uk Some C Examples Assignment : int j = 10 ; // space must be allocated to variable j Possibility 1: j is stored in a register, i.e. register $2 then
Typy danych. Data types: Literals:
Lab 10 MIPS32 Typy danych Data types: Instructions are all 32 bits byte(8 bits), halfword (2 bytes), word (4 bytes) a character requires 1 byte of storage an integer requires 1 word (4 bytes) of storage
7. MIPS Instruction Set Architecture
CSEE 3827: Fundamentals of Computer Systems, Spring 2011 7. MIPS Instruction Set Architecture Prof. Martha Kim (martha@cs.columbia.edu) Web: http://www.cs.columbia.edu/~martha/courses/3827/sp11/ Outline
Lab Work 2. MIPS assembly and introduction to PCSpim
Lab Work 2. MIPS assembly and introduction to PCSpim The goal of this work is for the student to become familiar with the data types and the programming in assembly (MIPS32). To realize this lab work you
Quiz for Chapter 2 Instructions: Language of the Computer3.10
Date: 3.10 Not all questions are of equal difficulty. Please review the entire quiz first and then budget your time carefully. Name: Course: Solutions in Red 1. [5 points] Prior to the early 1980s, machines
Array Declaration and Storage Allocation
Array Declaration and Storage Allocation The first step is to reserve sufficient space for the array: 1.data list:.space 1000 # reserves a block of 1000 bytes This yields a contiguous block of bytes of
The University of Nottingham
The University of Nottingham School of Computer Science A Level 1 Module, Autumn Semester 2007-2008 Computer Systems Architecture (G51CSA) Time Allowed: TWO Hours Candidates must NOT start writing their
Exceptions in MIPS. know the exception mechanism in MIPS be able to write a simple exception handler for a MIPS machine
7 Objectives After completing this lab you will: know the exception mechanism in MIPS be able to write a simple exception handler for a MIPS machine Introduction Branches and jumps provide ways to change
Integer Multiplication and Division
6 Integer Multiplication and Division 6.1 Objectives After completing this lab, you will: Understand binary multiplication and division Understand the MIPS multiply and divide instructions Write MIPS programs
Number Representation
Number Representation CS10001: Programming & Data Structures Pallab Dasgupta Professor, Dept. of Computer Sc. & Engg., Indian Institute of Technology Kharagpur Topics to be Discussed How are numeric data
ICS 233 Computer Architecture & Assembly Language
ICS 233 Computer Architecture & Assembly Language Assignment 3 SOLUTION: Procedures in MIPS Assembly Language For the following problems, the table holds C code functions. Assume that the first function
MIPS Calling Convention
MIPS Calling Convention This document summarizes the calling conventions that we expect you to use in ECE 314 for homework problems and assembly language programming projects. These are the rules for how
Loop Example. CMPE 325 Computer Architecture II. Loop Solution. Loops in C. Improved Loop Solution. Loop Efficiency. Assembly Language (cont)
CMPE 325 Computer rchitecture II Cem Ergün Eastern Mediterranean University ssembly Language (cont) Loop Example Consider the code where array is an integer array with 100 elements Loop: g = g + [i] i
Lecture 6 Machine language designed for the common case
Lecture 6 Machine language, the binary representation for instructions. We ll see how it is designed for the common case Fixed-sized (32-bit) instructions Only 3 instruction formats Limited-sized immediate
MIPS: The Virtual Machine
2 Objectives After this lab you will know: what synthetic instructions are how synthetic instructions expand to sequences of native instructions how MIPS addresses the memory Introduction MIPS is a typical
A single register, called the accumulator, stores the. operand before the operation, and stores the result. Add y # add y from memory to the acc
Other architectures Example. Accumulator-based machines A single register, called the accumulator, stores the operand before the operation, and stores the result after the operation. Load x # into acc
MIPS Architecture 32-bit processor, MIPS instruction size: 32 bits. Registers: Data formats: Instruction set:
MIPS Architecture 32-bit processor, MIPS instruction size: 32 bits. Registers: 1. 32 registers, notation $0, $1, $31 $0: always 0. $31: return address. $1, $26, $27, $28, $29 used by OS and assembler.
Syscall 5. Erik Jonsson School of Engineering and Computer Science. The University of Texas at Dallas
Syscall 5 System call 5 allows input of numerical data from the keyboard while a program is running. Syscall 5 is a bit unusual, in that it requires the use of register $v0 twice. In syscall 5 (as for
Number Representation
Number Representation Number System :: The Basics We are accustomed to using the so-called decimal number system Ten digits ::,,,3,4,5,6,7,8,9 Every digit position has a weight which is a power of Base
Machine code generation
Machine-Code Generation Cosmin Oancea cosmin.oancea@diku.dk December 2012 Structure of a Compiler Programme text Lexical analysis Binary machine code Symbol sequence Assembly and linking Syntax analysis
We Use High Level Languages. HLL Assembly Language. Assembly Language Machine Language. Machine Language Inputs to Digital System
We Use High Level Languages High Level Language temp = v[k]; v[k] = v[k+1]; v[k+1] = temp; There are many high level languages (HLLs) Java, C, C++, C#, Fortran, Basic, Pascal, Lisp, Ada, Matlab, etc. HLLs
Computer is a binary digital system. Data. Unsigned Integers (cont.) Unsigned Integers. Binary (base two) system: Has two states: 0 and 1
Computer Programming Programming Language Is telling the computer how to do something Wikipedia Definition: Applies specific programming languages to solve specific computational problems with solutions
Computer Systems Architecture
Computer Systems Architecture http://cs.nott.ac.uk/ txa/g51csa/ Thorsten Altenkirch and Liyang Hu School of Computer Science University of Nottingham Lecture 11: Pointers and References What does the following
Review 1/2. CS61C Characters and Floating Point. Lecture 8. February 12, Review 2/2 : 12 new instructions Arithmetic:
Review 1/2 CS61C Characters and Floating Point Lecture 8 February 12, 1999 Handling case when number is too big for representation (overflow) Representing negative numbers (2 s complement) Comparing signed
Arrays. Arrays, Argument Passing, Promotion, Demotion
Arrays Arrays, Argument Passing, Promotion, Demotion Review Introduction to C C History Compiling C Identifiers Variables Declaration, Definition, Initialization Variable Types Logical Operators Control
Reduced Instruction Set Computer (RISC)
Reduced Instruction Set Computer (RISC) Focuses on reducing the number and complexity of instructions of the ISA. RISC Goals RISC: Simplify ISA Simplify CPU Design Better CPU Performance Motivated by simplifying
Assignment 2 Solutions Instruction Set Architecture, Performance, Spim, and Other ISAs
Assignment 2 Solutions Instruction Set Architecture, Performance, Spim, and Other ISAs Alice Liang Apr 18, 2013 Unless otherwise noted, the following problems are from the Patterson & Hennessy textbook
We also introduced the MIPS processor and its instructions
5JJ70 Computation Implementatie van rekenprocessen Translate C into MIPS assembly Henk Corporaal December 2009 Welcome So far we covered almost all of C, and a large part of C++ We also introduced the
Standard printing function in C is printf Prints everything numbers, strings, etc. May be complex to use. Standard C library is called libc
Arrays and Structs and Pointers, Oh My! Programming in C Input and output Using printf Standard input and output Pointers Arrays Structures Combining these things together Arrays and Structs and Pointers,
CS 64 Lecture 5: Decision Instruc4ons
CS 64 Lecture 5: Decision Instruc4ons So Far Basic Arithme4c add, sub, addi, mult, div Load memory: lw $s0, 8($t0) Store memory: sw $s0, - 8 ($t0) Q1 What opera4on copies data from main memory to a register
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
a. Chapter 1: Exercises: =>
Selected Solutions to Problem-Set #1 COE608: Computer Organization and Architecture Introduction, Instruction Set Architecture and Computer Arithmetic Chapters 1, 2 and 3 a. Chapter 1: Exercises: 1.1.1
Programming the Basic Computer. lecture 8
Programming the Basic Computer lecture 8 Programming the Basic Computer A computer system includes both hardware and software. Hardware consist of the physical components. Software refers to computer programs.
Lecture 3: MIPS Instruction Set
Lecture 3: MIPS Instruction Set Today s topic: More MIPS instructions Procedure call/return Reminder: Assignment 1 is on the class web-page (due 9/7) 1 Memory Operands Values must be fetched from memory
Chapter 3 MIPS Assembly Language Morgan Kaufmann Publishers
Chapter 3 MIPS Assembly Language 1 Review MIPS instruction:fixed instruction size(32bit) and 3 simple formats bne or beq: R type or I-type? Using slt and beq to simulate branch if less than pseudo instruction
Basic Computer Organization
SE 292 (3:0) High Performance Computing L2: Basic Computer Organization R. Govindarajan govind@serc Basic Computer Organization Main parts of a computer system: Processor: Executes programs Main memory:
CSI 333 Lecture 2 Introduction to C: Part I 2 1 / 16
CSI 333 Lecture 2 Introduction to C: Part I 2 1 / 16 Basics of C Remark: Skim Chapters 1 through 6 of Deitel & Deitel. You will notice the following: C is (more or less) a subset of Java. (So, you are
MIPS Memory Organization
MIPS Memory Organization 1 In addition to memory for static data and the program text (machine code), MIPS provides space for the run-time stack (data local to procedures, etc.) and for dynamically-allocated
Python to C/C++ Fall 2011
Python to C/C++ Fall 2011 1. Main Program Python: Program code is indented after colon : def main(): body of program C/C++: Have more setup overhead. C: Both require #include directives to access libraries
Assembler Directives (cont..)
ASSUME DB - Defined Byte. DD - Defined Double Word DQ - Defined Quad Word DT - Define Ten Bytes DW - Define Word M. Krishna Kumar MAM/M2/LU6/V1/2004 1 ASSUME Directive - The ASSUME directive is used to
CSSE 232 Computer Architecture I Rose-Hulman Institute of Technology Computer Science and Software Engineering Department. Homework 1 Solutions
CSSE 232 Computer Architecture I Rose-Hulman Institute of Technology Computer Science and Software Engineering Department Homework 1 Solutions 1. (10 points) Please pay attention to this question. The
COMP 250 Fall Mathematical induction Sept. 26, (n 1) + n = n + (n 1)
COMP 50 Fall 016 9 - Mathematical induction Sept 6, 016 You will see many examples in this course and upcoming courses of algorithms for solving various problems It many cases, it will be obvious that
The Assembly Language Level
The Assembly Language Level Translators can be divided into two groups. When the source language is essentially a symbolic representation for a numerical machine language, the translator is called an assembler,
MPI and C-Language Seminars 2010
MPI and C-Language Seminars 2010 Seminar Plan (1/3) Aim: Introduce the C Programming Language. Plan to cover: Basic C, and programming techniques needed for HPC coursework. C-bindings for the Message Passing
Chapter 2: MIPS Instruction Set (cont d)
Chapter 2: MIPS Instruction Set (cont d) 1 Review Instruction Meaning add $s1,$s2,$s3 $s1 = $s2 + $s3 sub $s1,$s2,$s3 $s1 = $s2 $s3 addi $s1,$s2,4 $s1 = $s2 + 4 ori $s1,$s2,4 $s2 = $s2 4 lw $s1,100($s2)
Sources: On the Web: Slides will be available on:
C programming Introduction The basics of algorithms Structure of a C code, compilation step Constant, variable type, variable scope Expression and operators: assignment, arithmetic operators, comparison,
Roll Call. Erik Jonsson School of Engineering and Computer Science. The University of Texas at Dallas. Lecture #17: Final Session on SPIM; Bonus Set
Roll Call 1 Requirements for Test #3 Exemption 1. No unexcused absences to end of semester (written excuse required must be MD-verified illness or work-related, with written excuse from supervisor). 2.
CMSC 411 Computer Architecture Another MIPS64 ISA Quiz Fall, 2014 Dr. Michelle McElvany Hugue
CMSC 411 Computer Architecture Another MIPS64 ISA Quiz Fall, 2014 Dr. Michelle McElvany Hugue Address Comments Anyone? (1) DADDI R4, R0, # 6400 ;;; Make an integer 6400 (2) MTC1 F4, R4 ;;; copy bit pattern
Instruction Set Architecture. or How to talk to computers if you aren t in Star Trek
Instruction Set Architecture or How to talk to computers if you aren t in Star Trek The Instruction Set Architecture Application Compiler Instr. Set Proc. Operating System I/O system Instruction Set Architecture
Assembly Language Convention Guide
Intro Computer Systems Van Hentenryck Conventions are especially important in assembly code. Unlike higher-level languages, which provide inherent structure through branches, loops, and functions, assembly
Molecular Dynamics Simulations with Applications in Soft Matter Handout 7 Memory Diagram of a Struct
Dr. Martin O. Steinhauser University of Basel Graduate Lecture Spring Semester 2014 Molecular Dynamics Simulations with Applications in Soft Matter Handout 7 Memory Diagram of a Struct Friday, 7 th March
ARM & IA-32. Jin-Soo Kim Computer Systems Laboratory Sungkyunkwan University
ARM & IA-32 Jin-Soo Kim (jinsookim@skku.edu) Computer Systems Laboratory Sungkyunkwan University http://csl.skku.edu ARM (1) ARM & MIPS similarities ARM: the most popular embedded core Similar basic set
Lecture 03 Bits, Bytes and Data Types
Lecture 03 Bits, Bytes and Data Types In this lecture Computer Languages Assembly Language The compiler Operating system Data and program instructions Bits, Bytes and Data Types ASCII table Data Types
CS 2630 Computer Organization. Meeting 2: Bits, bytes, and memory Brandon Myers University of Iowa
CS 2630 Computer Organization Meeting 2: Bits, bytes, and memory Brandon Myers University of Iowa Where are we? Compiler Instruction set architecture (e.g., MIPS) translating source code (C or Java) Programs
Winter 2002 MID-SESSION TEST Friday, March 1 6:30 to 8:00pm
University of Calgary Department of Electrical and Computer Engineering ENCM 369: Computer Organization Instructors: Dr. S. A. Norman (L01) and Dr. S. Yanushkevich (L02) Winter 2002 MID-SESSION TEST Friday,
CSI 333 Lecture 17 MIPS Assembly Language (MAL): Part V (MIPS Instruction Formats) 17 1 / 16
CSI 333 Lecture 17 MIPS Assembly Language (MAL): Part V (MIPS Instruction Formats) 17 1 / 16 MIPS Instruction Formats Each MIPS machine instruction occupies one word (32 bits). Three instruction formats
Systems Architecture ARM Assembler Strings
Systems Architecture ARM Assembler Strings Strings p. 1/16 Characters or Strings A string is a sequence of characters ASCII 7-bit (American) character codes One byte per character (char) Unicode International
Example: Array Access
ECE232: Hardware Organization and Design Part 7: MIPS Instructions III http://www.ecs.umass.edu/ece/ece232/ Adapted from Computer Organization and Design, Patterson & Hennessy, UCB Example: Array Access
Number Representation
Number Representation COMP375 Computer Organization and darchitecture t How do we represent data in a computer? At the lowest level, a computer is an electronic machine. works by controlling the flow of
Today s Goals. Capacity of Binary Numbers. Binary Number System. Hexadecimal Number System. Octal Number System. CS246 Lec07. base
Today s Goals Number Systems Pointers Declaration Assignment Indirection/de-referencing Section 1 Decimal Number System (Base-10 number system) 123 = 1 100 + 2 10 + 3 = 1 10 2 + 2 10 1 + 3 10 0 = 123 10
Basic C Syntax. Comp-206 : Introduction to Software Systems Lecture 10. Alexandre Denault Computer Science McGill University Fall 2006
Basic C Syntax Comp-206 : Introduction to Software Systems Lecture 10 Alexandre Denault Computer Science McGill University Fall 2006 Next Week I'm away for the week. I'll still check my mails though. No
Question 1 (10 points):
Question 1 (10 points): Write a program that computes t0 t1 and leaves the result in register t2 You can use only the following instructions: addi, add, sub, sll, srl, nand, beq Do not worry about efficiency
Machine Code. How the Assembler Works
1 / 32 Machine Code -and- How the Assembler Works Mar 8 13, 2013 2 / 32 Outline What is machine code? RISC vs. CISC MIPS instruction formats Assembling basic instructions R-type instructions I-type instructions
Figure 1: Graphical example of a mergesort 1.
CSE 30321 Computer Architecture I Fall 2011 Lab 02: Procedure Calls in MIPS Assembly Programming and Performance Total Points: 100 points due to its complexity, this lab will weight more heavily in your
An Introduction to Assembly Programming with the ARM 32-bit Processor Family
An Introduction to Assembly Programming with the ARM 32-bit Processor Family G. Agosta Politecnico di Milano December 3, 2011 Contents 1 Introduction 1 1.1 Prerequisites............................. 2
As in high level languages, when programming in assembly language you should split up your program into smaller functions, that you can reuse.
jal and jr Functions and register conventions Slide 1 Stacks Implementing Stacks on the MIPS As in high level languages, when programming in assembly language you should split up your program into smaller
Lecture 11 Doubly Linked Lists & Array of Linked Lists. Doubly Linked Lists
Lecture 11 Doubly Linked Lists & Array of Linked Lists In this lecture Doubly linked lists Array of Linked Lists Creating an Array of Linked Lists Representing a Sparse Matrix Defining a Node for a Sparse
Arrays and Pointers (part 1)
Arrays and Pointers (part 1) EECS 2031 25 September 2016 1 Arrays l Grouping of data of the same type. l Loops commonly used for manipulation. l Programmers set array sizes explicitly. 2 1 Arrays: Example
Stack machines The MIPS assembly language A simple source language Stack-machine implementation of the simple language Readings: 9.1-9.
Code Generation I Stack machines The MIPS assembly language A simple source language Stack-machine implementation of the simple language Readings: 9.1-9.7 Stack Machines A simple evaluation model No variables
Instruction Set Architecture
Instruction Set Architecture Consider x := y+z. (x, y, z are memory variables) 1-address instructions 2-address instructions LOAD y (r :=y) ADD y,z (y := y+z) ADD z (r:=r+z) MOVE x,y (x := y) STORE x (x:=r)
Number Systems and. Data Representation
Number Systems and Data Representation 1 Lecture Outline Number Systems Binary, Octal, Hexadecimal Representation of characters using codes Representation of Numbers Integer, Floating Point, Binary Coded
CIS 190: C/C++ Programming. Lecture 1 Introduction and Getting Started
CIS 190: C/C++ Programming Lecture 1 Introduction and Getting Started This course will teach you the basics of C and C++ give you more programming experience be appropriate for majors and non-majors not
Final Exam Review. CS 1428 Fall Jill Seaman. Final Exam
Final Exam Review CS 1428 Fall 2011 Jill Seaman 1 Final Exam Friday, December 9, 11:00am to 1:30pm Derr 241 (here) Closed book, closed notes, clean desk Comprehensive (covers entire course) 25% of your
CS 430 Computer Architecture. Decisions in C/Assembly Language. William J. Taffe. David Patterson
CS 430 Computer Architecture Decisions in C/Assembly Language William J. Taffe using notes of David Patterson 1 Review (1/2) In MIPS Assembly Language: Registers replace C variables One Instruction (simple
8.5 Arrays of pointers to string
8.5 Arrays of pointers to string 211 8.5 Arrays of pointers to string In Chapter 7 we learned that an initialized string can be declared, for example, in the following way: char some_string[] = "Some initialization
Introduction to MIPS Programming with Mars
Introduction to MIPS Programming with Mars This week s lab will parallel last week s lab. During the lab period, we want you to follow the instructions in this handout that lead you through the process
Branching. We ll continue to look at the basics of writing C++ programs including. Overview
Branching Overview We ll continue to look at the basics of writing C++ programs including Boolean Expressions (need to know this before we can using branching and looping!) Branching J.S. Bradbury CSCI
UNIVERSITY OF CALIFORNIA Department of Electrical Engineering and Computer Sciences Computer Science Division. A Model of Programming Languages
UNIVERSITY OF CALIFORNIA Department of Electrical Engineering and Computer Sciences Computer Science Division CS61B Spring 1998 P. N. Hilfinger A Model of Programming Languages 1 Programming Models One
Translating C code to MIPS
Translating C code to MIPS why do it C is relatively simple, close to the machine C can act as pseudocode for assembler program gives some insight into what compiler needs to do what's under the hood do
CPU- Internal Structure
ESD-1 Elettronica dei Sistemi Digitali 1 CPU- Internal Structure Lesson 12 CPU Structure&Function Instruction Sets Addressing Modes Read Stallings s chapters: 11, 9, 10 esd-1-9:10:11-2002 1 esd-1-9:10:11-2002
Integer multiplication
Integer multiplication Suppose we have two unsigned integers, A and B, and we wish to compute their product. Let A be the multiplicand and B the multiplier: A n 1... A 1 A 0 multiplicand B n 1... B 1 B
1) String initialization can be carried out in the following ways, similar to that of an array :
Strings in C : Overview : String data type is not supported in C Programming. String is essentially a collection of characters to form particular word. String is useful whenever we accept name of the person,
Chapter 3. lw $s1,100($s2) $s1 = Memory[$s2+100] sw $s1,100($s2) Memory[$s2+100] = $s1
Chapter 3 1 MIPS Instructions Instruction Meaning add $s1,$s2,$s3 $s1 = $s2 + $s3 sub $s1,$s2,$s3 $s1 = $s2 $s3 addi $s1,$s2,4 $s1 = $s2 + 4 ori $s1,$s2,4 $s2 = $s2 4 lw $s1,100($s2) $s1 = Memory[$s2+100]
Going from Python to C
Going from Python to C Darin Brezeale December 8, 2011 Python is a high-level, interpreted language. C has many of the same types of programming constructs as in Python: arrays, loops, conditionals, functions,
MIPS Introduction. Reading: Chapter 3. Appendix A. Language of the Machine. More primitive than higher level languages
MIPS Introduction Reading: Chapter 3. Appendix A. Language of the Machine More primitive than higher level languages e.g., no sophisticated control flow such as for and while only simple branch, jump,
strsep exercises Introduction C strings Arrays of char
strsep exercises Introduction The standard library function strsep enables a C programmer to parse or decompose a string into substrings, each terminated by a specified character. The goals of this document
Strings in Java String Objects
Strings in Java are objects. They are instances of the class String (in the package java.lang). As is the case with other objects, String variables are actually references to a String object in memory.
198:211 Computer Architecture
198:211 Computer Architecture Topics: Lecture 8 (W5) Fall 2012 Data representation 2.1 and 2.2 of the book Floating point 2.4 of the book 1 Computer Architecture What do computers do? Manipulate stored