1 / 32

9/29: Lecture Topics

9/29: Lecture Topics. Conditional branch instructions Unconditional jump instructions Hexadecimal/Binary/Decimal Instruction encoding. Mailing List and Computer Labs. CSE410 mailing list Subscribe if you weren’t automatically or you use a different account

rsavoy
Download Presentation

9/29: 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/29: Lecture Topics • Conditional branch instructions • Unconditional jump instructions • Hexadecimal/Binary/Decimal • Instruction encoding

  2. Mailing List and Computer Labs • CSE410 mailing list • Subscribe if you weren’t automatically or you use a different account • Send email to majordomo@cs.washington.edu with ‘subscribe cse410’ in the body • Computer accounts • MSCC Lab in basement of Communications building • Username = passwd =

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

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

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

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

  7. 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) #

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

  9. 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); }

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

  11. 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 #

  12. Unconditional Jump • (Mostly) the same as branch • No choice about it; just go to the label • How are branch and jump different? • we’ll see when we get to instruction encoding

  13. Binary Numbers • Instead of 0-9 we can only use 0 and 1 • Also known as base-2 • Counting to 10ten in binary 0, 1, 10, 11, 100, 101, 110, 111, 1000, 1001, 1010 • Binary arithmetic 1 1011 +1010 10101 11001001 - 1010110

  14. Binary -> Decimal • Converting from Base-2 to Base-10 12 = 20 = 110 102 = 21 = 210 1002 = 22 = 410 10002 = 23 = 810 11102 = 1*23 + 1*22 + 1*21 + 0*20 = 8+4+2+0 = 1410 1010112 =

  15. Decimal -> Binary • Repeatedly divide by 2 until you reach 0 • Reverse the order of the remainders 5010 50/2 = 25 remainder 0 25/2 = 12 remainder 1 12/2 = 6 remainder 0 6/2 = 3 remainder 0 3/2 = 1 remainder 1 1/2 = 0 remainder 1 1100102 7510 75/2 = remainder /2 = remainder /2 = remainder /2 = remainder /2 = remainder /2 = remainder /2 = remainder

  16. Hexadecimal Numbers • Instead of 0-9 we use 0-15 • 0-15 is confusing so we use 0-9, A-F • Also known as base-16 • Counting to 18ten in hex 1, 2, 3, 4, 5, 6, 7, 8, 9, A, B, C, D, E, F, 10, 11, 12 • Hex arithmetic 1 1 2E97 +A2B3 D14A A3AD38B993CA93C930B -A3AD38B993CA93C930A

  17. Hexadecimal <-> Binary • Each four binary digits represents one hexadecimal digit • Can quickly convert either way • 0x2A07 = 0010 1010 0000 0111 • 1111 0011 0101 1011 = 00002 = 016 00012 = 116 00102 = 216 00112 = 316 01002 = 416 01012 = 516 01102 = 616 01112 = 716 10002 = 816 10012 = 916 10102 = A16 10112 = B16 11002 = C16 11012 = D16 11102 = E16 11112 = F16

  18. Hexadecimal -> Decimal • Converting from Base-16 to Base-10 116 = 160 = 110 1016 = 161 = 1610 10016 = 162 = 25610 100016 = 163 = 153610 A32 = A*161 + 3*160 = 10*161 + 3*160= 160 + 3 = 163

  19. Decimal -> Hexadecimal • Repeatedly divide by 16 until you reach 0 • Reverse the order of the remainders 50010 500/16 = 31 remainder 4 31/16 = 1 remainder 15 (F) 1/16 = 0 remainder 1 1F416

  20. What you need to know • Be able to convert to/from small decimal numbers from/to binary or hex • Be able to/from convert any binary number from/to a hex number

  21. Stored Program • So far, we’ve seen that data comes from memory • It turns out that the program comes from memory also • Each instruction in the program has an address • Von Neumann computer (p. 33)

  22. Program Layout (p. 160) Address 0 Reserved 0x00400000 Program instructions Text 0x10000000 Static data Global variables 0x10008000 Dynamic data and stack 0x7fffffff

  23. The Text Segment • Let’s zoom in on the text segment: 0x00400000 Text 0x10000000 0x00400000 add $t0, $t1, $t2 0x00400004 sub $t0, $t0, $t3 lw $s1, 4($t0) 0x00400008

  24. Jump Register • Now we’re ready for the jr instruction • Syntax: • Effect: jump to the instruction at the address in $t0 jr $t0

  25. Another Look at Labels • Labels are text tags • The assembler translates them into addresses and does search-and-replace loop: add $t0, $t0, $t0 bne $t0, $t1, loop sw $t2, 0($t3)

  26. Instruction Encoding • How does the assembler translate each instruction into bits? add $t0, $s1, $s2 assembler 00000010001100100100000000100000

  27. Fields • Split the 32-bit instruction into fields: • op+funct: Which instruction? • rs, rt: Register source operands • rd: Register destination operand 32 bits op rs rt rd shamt funct 6 bits 5 bits 5 bits 5 bits 5 bits 6 bits

  28. Encoding an add instruction • Let’s translate: • Opcode for add is 000000 (p. A-55) • The funct for add is 100000 • The code for $t0 is 01000 (p. A-23) • The code for $s1 is 10001 • The code for $s2 is 10010 add $t0, $s1, $s2

  29. Instruction Formats • The 32 bits can be split up more than one way • For add, it was 6-5-5-5-5-6 • This is called R-format • For lw, we use 6-5-5-16 instead • This is called I-format 32 bits op rs rt address 6 bits 5 bits 5 bits 16 bits

  30. Translating into I-format • The opcode for lw is 100011 • The code for $t0 is 01000 • The code for $t1 is 01001 • Binary for 100 is lw $t0, 100($t1)

  31. Branch vs. Jump • Branch instructions use the I-format • The destination address is 16 bits • You can only branch ±32KB away • Jump instructions use another format called the J-format • The destination address is 26 bits • You can jump up to ±32MB away • What’s the tradeoff?

  32. What to Take Away • I don’t care if you: • Know how many bits are in each field • Know what the opcodes are • Know what the codes for the registers are • I do care that you: • Know what fields are • Know why we need more than one instruction format

More Related