Write Two 8 Bit Programs

Objectives

1. Write, assemble and run two 8 bit programs.

Notes

• The basic structure of an if is

  •       test a variable 
          if the result is not what you want branch to out
              body of the then clause
    out:  instructions following if 

• The basic structure of an if-else is

  •       test a variable 
          if the result is not what you want branch to else
              body of the then clause
              branch to out
    else:     body of the else clause
    out:  instructions following if 

• The basic structure of a while/for loop is

  •          initialize the lcv 
    top:     test a condition
             branch  out of the loop if the condition is met
    
             do some loop body things
             change the lcv
    
             branch back to the test condition.
    
    done:    instructions following the loop.

• We could also do a while loop

  •         initialize the lcv
    top:    do the body stuff
            test the lcv
            branch on result of test to top of body
    
            instructions following loop

• Side note: you can build these differently, with branches in the middle of the if/loop, but stick to what you know.
• The 8 bit computer has two conditional and one unconditional branch.
• Conditional:
  • jz : if the last operation of the ALU produced a zero, branch to the target.
  • jc: if the last operation of the ALU produced a carry, branch to the target.
• Unconditional :
  • j: branch to the target.
• To set the values in the flag register we perform an ALU operation
  • add
  • sub
• These set two flags:
  • zero: contains a 1 if the last operation produced a 0
  • carry: contains a 1 if the last operation produced a carry
• Side note, other architectures have far more instructions in these two classes, and far more flags.
• When I write assembly programs:
  • I usually write some c/c++ code first.
  • But I don't use high level constructs (vector, list, ...)
  • Probably not for loops for a while either.
  • Then write assembly to match that code.
• Write a program that will count from 10 to 1

  • i = 10
    while (i > 0) {
        cout << i
        i = i -1
    } 

  • I will store i in the register (so load 10 or something initially)
  • I will need to store 1 in memory so I can subtract it.
  • How will I test i > 0?
  • Just a jz after the subtraction
  • I propose the following code

    0      loadi 11    0x5B
    1  top sub one     0x36
    2      jz out      0x85
    3      output      0xE0
    4      j top       0x61
    5  out halt        0xF0
    6  one 1           0x01
    

  • Easy to copy and paste: 0x5B 0x36 0x85 0xe0 0x61 0xf0 0x01
• The integers a and b are stored in memory. Write a program that prints the larger.
  • Probably need to look at jc.
  • When in a carry produced?
    • Addition is probably not useful here
    • Subtraction is probably the operation
  • Let's write a little program to experiment with jc

    • 0          load a        0x18
      1          sub b         0x39
      2          jc carry      0x75
      3          loadi 1       0x51
      4          j done        0x66
      5  carry:  loadi c       0x1b
      6  done    out           0xe0
      7          halt          0xf0
      8  a       3             0x03
      9  b       4             0x04
      a  one     1             0x01
      b  c       c             0x0c 

    • Easy copy and paste: 0x18 0x39 0x75 0x51 0x66 0x1b 0xe0 0xf0 0x03 0x04 0x01 0x0c
    • Change the 3 and 4 to produce a carry
    • Do some simple math to see what happens.
  • It is easy to modify this code to do the task.