1. ECE 3430 – Intro to Microcomputer Systems
ECE 3430 – Introduction to Microcomputer Systems University of Colorado at Colorado Springs
Lecture #7
Agenda Today
Decoding Machine Code
Data Direction Registers
Logical Instructions (AND, OR, EOR)
Arithmetic Instructions (ADD, SUB, MUL, IDIV)
More Instruction Execution and Timing
Lecture #7
ECE 3430 – Intro to Microcomputer Systems
Fall 2009

2. ECE 3430 – Intro to Microcomputer Systems
Decoding Machine Code
Decoding Machine Code
- The process of creating the assembly language (including mnemonics) for the
opcodes and operands scattered throughout program memory (the machine code).
- If we know the contents of the program memory, we can reverse-engineer the
code to assembly level.
- There is a single mapping from machine code to assembly code and
vice-versa.
- FYI: It is not always possible to reverse-engineer machine code to a source
code form more abstract than assembly (i.e. to the C or C++ source code level).
Information is combined and dismissed during the “higher level language” to
assembly translation. There can be an infinite number of ways to write higher
level code that ultimately produces the same machine code. Debuggers for
these higher level languages rely on other constructs (such as symbol files)
to map a particular machine instruction back to a single line of source code.
Lecture #7
ECE 3430 – Intro to Microcomputer Systems
Fall 2009

3. ECE 3430 – Intro to Microcomputer Systems
Decoding Machine Code
Program Execution:
The opcode byte(s) contain all the information about size and addressing mode of the instruction.
The first opcode inherently tells you where the next opcode is stored in memory—and so on.
Just as assemblers can assemble your assembly code into machine code, inverse-assemblers
can take machine code and produce the original assembly code.
Why would you want to do this? 1) To verify that the cross-assembler did what you expected ) If the address & data busses are “probe-able”, you can use
a logic analyzer to track the program and find our where
the programs are and what they are doing (nicer logic analyzers
have “built-in” inverse assemblers for many common CPUs). .
The pink book tells you what the opcode is for a given mnemonic and addressing mode.
The pink book also tells you what the mnemonic and addressing mode is for a given opcode.
*.asm file
Program Memory
cross-assembler
LDAA #$FF
$86 $FF …
*.asm file
LDAA #$FF
inverse-assembler (machine code decoding)
Lecture #7
ECE 3430 – Intro to Microcomputer Systems
Fall 2009

4. ECE 3430 – Intro to Microcomputer Systems
Decoding Machine Code
Decode the following: $96, $30, $8B, $07 1) First we look up $96 in the pink book. We know that it is an opcode because nothing precedes it. From here on out however, we must keep track of where instructions begin and end. $96 = LDAA DIR 2) We see that there is one byte of operand because $96 uses direct addressing This means the next byte is the operand for LDAA ($30) The first instruction is LDAA $30. If the opcode was not found in the table, then it may
be a multi-byte opcode (as is used by LDY for example). You then have to consider the
next byte as well when decoding the instruction. 3) Since the first instruction is complete, the next byte is the opcode for the next instruction So we look it up in the pink book: $8B = ADDA IMM Since ACCA is 8-bits wide, the value added to it is 8-bits. Hence, $07 is the only operand
for the instruction.
The second instruction is ADDA #$07. 4) The complete code for this block of raw memory is: LDAA $ ADDA #$07
Lecture #7
ECE 3430 – Intro to Microcomputer Systems
Fall 2009

5. Data Direction Registers
The HC11 has bi-directional ports, so how do we change them from an input to an output?
There are configuration registers that handle this. Each of the following
registers has a designated memory address mapped into the internal register
block of the HC11 (these can be found in the pink book too): DDRB ($0006) = data direction for port B DDRC ($0007) = data direction for port C DDRD ($0009) = data direction for port D PACTL ($0026)= data direction for PA3 and PA7
(may be typo in older books)
Writing a ‘0’ to these registers turns that pin into an input (reset).
Writing a ‘1’ to these registers turns that pin into an output.
Lecture #7
ECE 3430 – Intro to Microcomputer Systems
Fall 2009

6. Bit-Wise Manipulation of Memory
The HC11 is a byte-addressable architecture.
This means that each address targets a byte
stored in memory. So what if you want to
change one bit in memory (without effecting
the other bits in that byte)?
Apply boolean logic:
AND: Force a bit to zero or no change.
OR: Force a bit to one or no change.
EOR: Toggle a bit to opposite state or no change.
Lecture #7
ECE 3430 – Intro to Microcomputer Systems
Fall 2009

7. Bit-Wise Manipulation of Memory
The AND, OR, and EOR instructions conceptually form a logic gate
between each corresponding bit of the operand and the value
already stored in the accumulator. These logical operations can only
be performed on accumulator A and B in the HC11.
ANDA operand  bitwise AND Ex) (ACCA)
ANDB operand  M()
x x x x x x x x
ORAA operand  bitwise OR
ORAB operand
EORA operand  bitwise exclusive OR
EORB operand
Logic Gate
8 of these
Lecture #7
ECE 3430 – Intro to Microcomputer Systems
Fall 2009

8. Bit-Wise Manipulation of Memory
These logical instructions are useful for setting, clearing, or toggling bits within a byte: OR w/ 1 to set LDAA $ ORAA #% ; will force PA4 to ‘1’ STAA $00 AND w/ 0 to clear LDAA $ ANDA #% ; will force PA4 to ‘0’
STAA $00
EOR w/ 1 to toggle LDAA $00
EORA #% ; will toggle the state
; of PA4
STAA $00
Lecture #7
ECE 3430 – Intro to Microcomputer Systems
Fall 2009

9. Arithmetic Instructions: The ADD Instruction
ADD – A general name for a set of HC11 addition instructions. The destination
“address” must be a register or accumulator.
Example add instructions:
ADDA: A + M  A (4 addressing modes for M)
ADDB: B + M  B (4 addressing modes for M)
ADDD: D + M:M+1  D (4 addressing modes for M)
ADCA: A + M + C  A (4 addressing modes for M)
ADCB: B + M + C  B (4 addressing modes for M)
ABA: A + B  A (inherent addressing)
ABX: IX + 00:B  X (inherent addressing)
ABY: IY + 00:B  Y (inherent addressing)
Lecture #7
ECE 3430 – Intro to Microcomputer Systems
Fall 2009

10. Arithmetic Instructions: The ADD Instruction
ADD Instruction Execution – Ex) ADDA $10 = $9B, $10
(2 bytes, 3 clock cycles) Step 1: PC is put on the address bus ($E000) and a READ is initiated. The data ($9B) is put on the data bus by the memory and grabbed by the CPU. The control unit decodes the instruction and recognizes that it is an ADDA using direct addressing. The PC
is incremented (PC = PC+ 1 = $E001). Step 2: PC is put on the address bus ($E001) and a READ is initiated. The data ($10) is put on the data bus and
grabbed by the CPU. The PC is incremented
(PC = PC + 1 = $E002). Step 3: The DIRECT address ($0010) is put on the address bus and
the data at that address M($0010) is put on the data bus.
This value is added to ACCA and the result is left in ACCA.
Memory
$0010 data
- -
$E000 $9B
$E001 $10
$E002 -
Lecture #7
ECE 3430 – Intro to Microcomputer Systems
Fall 2009

11. Arithmetic Instructions: The ADD Instruction
Write code to add M($0010) and M($0011) and store in ACCA – LDAA $10 ; ACCA = M($0010) using DIRECT addressing LDAB $11 ; ACCB = M($0011) using DIRECT addressing ABA ; ACCA = ACCA + ACCB using INHERENT addressing
STAA $0040 ; store result in $0040 (RAM on the MicroStamp)
The above would add the contents of $0010 and $0011 together. The sum resides in
ACCA until we store the result out to memory. In this case the result is stored
in memory location $0040.
Lecture #7
ECE 3430 – Intro to Microcomputer Systems
Fall 2009

12. Arithmetic Instructions: The SUB Instruction
SUB – A general name for a set of HC11 instructions performing subtraction. Again,
the destination “address” must be a register or accumulator.
Example subtract instructions:
SUBA: A – M  A (4 addressing modes for M)
SUBB: B – M  B (4 addressing modes for M)
SUBD: D – M:M+1  D (4 addressing modes for M)
SBCA: A – M – C  A (4 addressing modes for M)
SBCB: B – M – C  B (4 addressing modes for M)
SBA: A – B  A (inherent addressing)
Lecture #7
ECE 3430 – Intro to Microcomputer Systems
Fall 2009

13. Arithmetic Instructions: The SUB Instruction
Ex) SBA ; A = A-B (INH) SUBA #$10 ; A = A - $10 (IMM) SUBA $10 ; A = A – M($10) (DIR) SBCA $10 ; A = A – M($10) – C (DIR)
What happens if the result is negative?  The “N” bit in the CCR is set.
What happens if two’s compliment overflow occurs?  The “V” bit in the CCR is set.
Lecture #7
ECE 3430 – Intro to Microcomputer Systems
Fall 2009

14. Arithmetic Instructions: The MUL Instruction
The MUL instruction uses inherent addressing. It does an 8-bit,
unsigned multiplication of the contents in ACCA and ACCB and
stores the 16-bit, unsigned result in ACCD:
A x B  D
Ex: Multiply the contents of $0042 by 5 and store back to $0043:
LDAA $0042
LDAB #5
MUL
STD $0043
Lecture #7
ECE 3430 – Intro to Microcomputer Systems
Fall 2009

15. Arithmetic Instructions: The IDIV Instruction
The IDIV instruction uses inherent addressing. It does a 16-bit,
unsigned integer divide using the contents of index register X and
ACCD and produces a 16-bit quotient and 16-bit remainder:
D / IX : 16-bit quotient  IX, 16-bit remainder  D
Ex: Divide the contents of $0042 by 5 and store quotient to $0044 and remainder to $0046:
LDD $0042
LDX #5
IDIV
STX $0044
STD $0046
There is also an FDIV instruction which stands for fractional divide (not floating divide).
The HC11 has no floating point support.
Lecture #7
ECE 3430 – Intro to Microcomputer Systems
Fall 2009

16. Instruction Execution/Timing
Timing - An electronic computer is a synchronous system. - This means that all circuitry is synchronous to the ‘1’ system clock (memory, CPU, I/O). - The system clock is derived from a crystal oscillator (XTAL Clock) - The system clock (E-clock) is the XTAL clock divided by 4 E-clock = XTAL Frequency Our System (MicroStamp): - XTAL = MHz E-clock = 2.1 MHz Cycle Time = 1/(E-clock freq) = 477ns Other common XTAL frequencies: 8.0 MHz, 4.0 MHz
Ex) How long does the instruction “LDAA $FF” take to execute? - First we recognize that we are using direct addressing - Second, we go to the pink book to find out how many cycles the instruction takes (LDAA DIR = 3 clocks) Execution Time = (# of cycles)(execution time per clock) = (3)(477ns) = ns
May be 8.0 MHz on MicroStamp!
Lecture #7
ECE 3430 – Intro to Microcomputer Systems
Fall 2009

17. Instruction Execution/Timing
Instruction Execution: STAA $20 (DIR = 3 clock cycles) (machine = $97, $20) Step 1 - READ Opcode from PC location - PC = $E000 is put on the address bus from the PC - $97 is output from memory onto the data bus, CPU receives $ PC is incremented ($E001) Step 2 - READ Operand from PC location - PC = $E001 is put on the address bus from the PC - $20 is output from memory onto the data bus, CPU receivers $ PC is incremented ($E002) Step 3 - $0020 is output to address bus from CPU ACCA() is put onto the data bus - a WRITE is performed - the data that in in ACCA is stored into memory at $0020 Timing - READ Opcode = 1 clock cycle Total = 3 cycles - READ Operand = 1 clock cycle Time = (3)(477ns) = 1.43us - WRITE data = 1 clock cycle
Lecture #7
ECE 3430 – Intro to Microcomputer Systems
Fall 2009

18. ECE 3430 – Intro to Microcomputer Systems
Code Execution
How long does the following instruction take (i.e., execution time)? XTAL = 8MHz SUBD $1020
First find the time it takes for 1 cycle: E-clock = XTAL/4 = 2MHz Time/cycle = 1/(2MHz) = 500ns
Next find the # of cycles this instruction takes from the pink book: SUBD EXT = 6 cycles
Multiply (# of cycles)(time/cycle) = (6)(500ns) = 3us
Lecture #7
ECE 3430 – Intro to Microcomputer Systems
Fall 2009

19. ECE 3430 – Intro to Microcomputer Systems
Code Execution
Add the contents of M($0040) and M($0041) and store result in M($0042): LDAA $40 ; ACCA = M($0040) LDAB $41 ; ACCB = M($0041) ABA ; ACCA = ACCA + ACCB STAA $42 ; M($0042) = ACCA
1) How much memory does this code take? LDAA $40 ; 2 bytes LDAB $41 ; 2 bytes ABA ; 1 byte STAA $42 ; 2 bytes
7 bytes
2) How long does this code take? LDAA $40 ; 3 cycles XTAL = 8MHz LDAB $41 ; 3 cycles E-clock = 8MHz/4 = 2 MHz ABA ; 2 cycles Time/cycle = 1/E-clock = 500ns STAA $42 ; 3 cycles
11 cycles (11)(500ns) = 5.5us
Lecture #7
ECE 3430 – Intro to Microcomputer Systems
Fall 2009

20. ECE 3430 – Intro to Microcomputer Systems
Code Execution
Can we do it better? LDAA $40 ; ACCA = M($40) ADDA $41 ; A = A + M($41) STAA $42 ; M($42) = ACCA
1) How much memory does this code take? LDAA $40 ; 2 bytes ADDA $41 ; 2 bytes STAA $42 ; 2 bytes
6 bytes
2) How long does this code take? LDAA $40 ; 3 cycles XTAL = 8MHz ADDA $41 ; 3 cycles E-clock = 8MHz/4 = 2 MHz STAA $42 ; 3 cycles Time/cycle = 1/E-clock = 500ns
9 cycles (9)(500ns) = 4.5us
Lecture #7
ECE 3430 – Intro to Microcomputer Systems
Fall 2009

21. ECE 3430 – Intro to Microcomputer Systems
Code Execution
What is the Improvement? Size: (7-6) x 100 = 14.3% Speed: (5.5 – 4.5) x 100 = 18.2%
A small change in how we chose to implement the code resulted in an
improvement in both time and space.
If the code were executed thousands of times, the size and speed improvements
would become very apparent (if executed in a loop for example)!
Lecture #7
ECE 3430 – Intro to Microcomputer Systems
Fall 2009

22. ECE 3430 – Intro to Microcomputer Systems
Code Execution
How many reads and writes were performed? LDAA DIR : 3 cycles : READ Opcode : READ Operand : READ M(DIR) ADDA DIR : 3 cycles : READ Opcode : READ Operand : READ M(DIR) STAA DIR : 3 cycles : READ Opcode : READ Operand : WRITE M(DIR) Total: 8 reads write
Lecture #7
ECE 3430 – Intro to Microcomputer Systems
Fall 2009

23. ECE 3430 – Intro to Microcomputer Systems
Code Execution
What have we forgotten? The carry bit. We are not taking into account if there was a carry out. You have to write your code to account for this if you care
about it (multi-precision arithmetic).
Is this operation signed or unsigned? Doesn’t matter. Addition and subtraction works for both. How the rest of the
program uses the results of the add/subtract operation differs depending on
whether you are dealing with signed or unsigned values (it is all in how you
interpret the binary).
Lecture #7
ECE 3430 – Intro to Microcomputer Systems
Fall 2009

24. ECE 3430 – Intro to Microcomputer Systems
Code Execution
Where is the program counter after the code is executed?
ANSWER: $E006, that is the location of the opcode for the next instruction.
Memory
$E000 $96 LDAA $40
$E001 $40 -
$E002 $9B ADDA $41
$E003 $41 -
$E004 $97 STAA $42
$E005 $42 -
$E006 -
Lecture #7
ECE 3430 – Intro to Microcomputer Systems
Fall 2009

25. ECE 3430 – Intro to Microcomputer Systems
End of Exam 1 Material
This is the end of the exam 1
material.
Prepare questions for next lecture.
Lecture #7
ECE 3430 – Intro to Microcomputer Systems
Fall 2009