Topics:

• Overview (Chapters 1, 2)
  • 1: Nothing directly asked about this, just for orientation.
  • 2: Skip Chapter 2.

• ints (4.1, 4.2)
  • Conversions between binary, decimal, hexadecimal
  • Integers: 2s complement for negative numbers
  • -13: write 13 in binary, complement, add 1

• doubles (4.8)
  • Conversions between scientific notation and internal bit representation of a double, using the IEEE standard.

• MIPS Assembly Language (Chapter 3, 4.4)
  • Format, constants in hex or decimal, comments following #
  • Registers, 32: $0-$31, with symbolic names (but don't need to memorize them)
  • Basic instructions
    • Arithmetic (add, sub, and, or)
    • Arithmetic immediate (addi, ori)
    • Load/Store (lw, sw) -- uses offset in bytes to form an address
    • Load address (pseudo: la, uses lui and ori)
  • Branches
    • bne, beq (offset in words from PC)
    • slt
    • all other branches are pseudo instructions
  • Jumps
    • j, jal (absolute addr in words)
    • jr (jump to address in a register)
  • pseudo-instructions, and simulating them with real instructions: li, move, la, blt, mul, b
  • Coding loops
  • Arrays, and their access (in memory, must use lw or sw).
  • Functions and function calls (use jal to call and jr $ra to return.
  • parameters to functions ($a0 - $a3), returned values ($v0, $v1), or on the stack.
  • Use of the stack: local variables, local (automatic) arrays, values saved
  • Recursion [example in class, but since the recursion lab is not complete, there won't be questions about recursion]
  • Logical instructions (shifts (sll, srl), and, or, etc.)
  • The assembly and compilation processes:
    • High-level source(C/C++), transformed by compiler to:
      
    • Assembler language program, transformed by assembler to:
      
    • Object file in machine language, transformed with other object files by linker to:
      
    • Executable module, loaded into a computer by loader and executed.

• MIPS Machine Language (Chapter 3)
  • High order 6 bits is Op code, saying which instruction it is.
  • Basic types
    • R-type (register), usually 3 registers (arithmetic, logical, slt, jr)
      Op code is always 0, and low order 6 bits says which R-type it is.
      Registers given in order: operand1, operand2, destination.
    • I-type (immediate), lw, sw, beq, bne, addi, lui (uses low order 16-bit 2s-complement constant)
    • J-type (jump), j, jal (Uses low order 26-bit constant, as a word address. Get a 28-bit constant as a byte address.)
  • Hand conversion of machine language into assembly (dis-assembly) [Not emphasized, since this is in Lab 8]
  • Hand conversion of assembly into machine language (assembly) [Not emphasized, since this is in Lab 8]

• Construction of NAND, NOR, NOT, AND, OR gates from CMOS transistors: gates from transistors (PDF).

• Combinational Logic (B.1, B.2, B.3)
  • Truth tables, boolean algebra, logic equations
  • AND, OR and NOT gates
  • Combinational logic
    • Decoders
    • Multiplexors
    • Create logic circuit to represent arbitrary truth table. (Skip PLAs, Don't Cares)

• About binary integers (especially 2s complement) and about formats for doubles.
• Asking for MIPS assembler programs, including loops, arrays (loads and stores), functions (including register conventions and saving/restoring registers using the stack).
• Use of other assembler instructions, including slt and la (and how it uses lui and ori to create a 32-bit constant).
• About other pseudo-instructions.
• Format of MIPS machine instructions.
• About the assembly process.
• About the construction of gates for CMOS transistors (from handout).
• About converting a truth table to a combinational logic circuit.
• Multiplexors, decoders.
• Consider the following assembler instruction:

  
         beq  $t0, $t1, Label
           ...  # a large number of instructions
   Label:         
  

  1. This instruction will not work in case Label is "too far away." Say precisely how far "too far away" is. (Be sure to say whether your answer is in bytes or words.)
  2. In case Label is too far away as in (b) above, show how the beq instruction could be changed to two instructions that would work unless Label is really a long ways off.