1 / 26

9/27: Lecture Topics

9/27: Lecture Topics. Memory Addressing (naming) Address space sizing Data transfer instructions load/store on arrays on arrays with variable indices Conditional branch instructions. If nobody every writes assembly, why learn it?. Why did people used to learn assembly?

arangel
Download Presentation

9/27: Lecture Topics

An Image/Link below is provided (as is) to download presentation Download Policy: Content on the Website is provided to you AS IS for your information and personal use and may not be sold / licensed / shared on other websites without getting consent from its author. Content is provided to you AS IS for your information and personal use only. Download presentation by click this link. While downloading, if for some reason you are not able to download a presentation, the publisher may have deleted the file from their server. During download, if you can't get a presentation, the file might be deleted by the publisher.

E N D

Presentation Transcript


  1. 9/27: Lecture Topics • Memory • Addressing (naming) • Address space sizing • Data transfer instructions • load/store • on arrays • on arrays with variable indices • Conditional branch instructions

  2. If nobody every writes assembly, why learn it? • Why did people used to learn assembly? • only language available, faster • A few people still write assembly • compiler/OS writers, embedded systems, games • It gives you an understanding of a program’s performance • procedure calls • It’s a building block for more important topics • pipelining, caching, operating systems • Better understanding of computer science

  3. Memory and Addressing • Only so many registers, but memory holds millions of data elements • Think of memory as a big array Address Data 01011010 0 Each address is a 32-bit number describing a location... ...and each data element is 8 bits of information. 10011001 1 2 10001111 3 11110010 4 00011001

  4. MIPS Information Units • Data types and size: • byte (eight bits) • half-word (two bytes) • word (four bytes) • float (four bytes, single precision) • double (eight bytes, double precision) • Memory is byte addressable • Data types start at an address divisible by the data type size (alignment)

  5. Word Alignment • Why do you think so many architectures use alignment? Address Data 0 4 8 12 16

  6. How Big Can Memory Be? • How big is an address? • 32 bits • How many addresses are there? • 232 = about 4 billion • How much data lives at each address? • 1 byte • How much memory can this computer have? • 4 billion x 1 byte = 4 GB

  7. Some Perspective • Today’s attitude: • 32 bits is definitely not enough for long • We hope 64 bits will be enough for a while • The attitude a while back: • 16 bits is enough for all time! • Who could possibly use up 64K of memory?

  8. Loads and Stores • Data transfer instructions let us • load data from memory to registers • store data from registers into memory • In MIPS, all data must be loaded before use and stored after use • Load-store architecture • lw instruction fetches a word • sw instruction stores a word

  9. Alternatives to Load-Store (p. 191) • register-register is another name for load-store (MIPS) • accumulator architectures had only one register (EDSAC) • register-memory architectures allow one operand to be in memory (IBM 360, Intel 80386) • memory-memory architectures allow both operands to be in memory (DEC VAX)

  10. Load Syntax • first argument: where to put the data • second argument: offset • third argument: address Desired result: MIPS assembly: Load the word at the address in $s0 into register $t0 Load the word at the address in $s0 plus 4 into $t0 lw $t0, 0($s0) lw $t0, 4($s0)

  11. A Related Concept: move • lw and sw are for moving data between memory and registers • move is for copying data from one register to another • common usage: zero a register move $t0, $0

  12. “Complex” Example Revisited Desired result: f = (g + h) - (i + j) f, g, h, i, j are in registers $s0, $s1, $s2, $s3, $s4, respectively MIPS assembly: add $s0, $s1, $s2 sub $s0, $s0, $s3 sub $s0, $s0, $s4

  13. “Complex” Example with L/S Desired result: f = (g + h) - (i + j) load g, h, i, j, compute, then store f Address Data MIPS assembly: f 200 g 204 208 h add $s0, $s1, $s2 sub $s0, $s0, $s3 sub $s0, $s0, $s4 212 i 216 j

  14. Arrays in Assembly Programs • One reason for lw syntax is arrays • keep the base address in a register • lw and sw on offsets into the array • Example: int A[10]; A[0] = 0; A[1] = 0; # addr of A in $t0 sw $0, 0($t0) sw $0, 4($t0)

  15. Variable Array Indexing • Very common use of arrays: walk through the array by incrementing a variable • lw and sw instructions allow offset to be specified: • as a constant • as the contents of a register vs. lw $t0, 4($t2) lw $t0, $t1($t2)

  16. Array Example Idea: translate g = h + A[i] into assembly, assuming Base address of A is in $s3 g, h, i in $s1, $s2, $s4

  17. Operation Types • Remember these? • Arithmetic • add, sub, mult, div • Data Transfer • lw, sw, lb, sb • Conditional Branch • beq, bne • Unconditional Jump • j, jr, jal

  18. Conditional Branch A change of the flow of control of the program that depends on a condition ... ... ? ... yes no ...

  19. Control flow in C • Conditional branch constructs: • while, do while loops • for loops • Unconditional jump constructs: • goto • switch statements

  20. Branching Instructions • beq • bne • other real instructions: b, bgez, bgtz, more... • other pseudoinstructions: beqz, bge, bgt, ble, blt, more...

  21. Pseudoinstructions • One-to-one mapping between assembly and machine language not strictly true • Assembler can do some of the work for you • Example: bgt is a real instruction; blt is a pseudoinstruction • move is a pseudoinstruction

  22. Labels in MIPS • MIPS allows text tags • a name for a place to branch to • Under the covers, the assembler converts the text tag into an address loop: add $t0, $t0, $t0 # bne $t0, $t1, loop # sw $t2, 0($t3) #

  23. Building a while loop in MIPS Idea: translate i=0; while(i<100) { i++; } into assembly.

  24. How about a for loop? • One answer: translate from for to while, then use while loop conventions • This is typically how compilers handle loops i=0; while(i<N) { do_stuff(i); i++; } for(i=0; i<N; i++) { do_stuff(i); }

  25. Example C Program int array[100]; void main() { int i; for(i=0; i<100; i++) array[i] = i; }

  26. An Assembly Version main: move $t0, $0 # la $t1, array # start: bge $t0, 100, exit # sw $t0, 0($t1) # addi $t0, $t0, 1 # addi $t1, $t1, 4 # j start # exit: j $ra #

More Related