Lecture 3 Addressing Modes, Instruction Samples, Machine Code, Instruction Execution Cycle

Transcription

1 Lecture 3 Addressing Modes, Instruction Samples, Machine Code, Instruction Execution Cycle Contents 3.1. Register Transfer Notation HCS12 Addressing Modes Inherent Mode (INH) Immediate Mode (IMM) Direct mode (DIR) Extended mode (EXT) Relative mode (REL) Indexed Mode (INDEX)... 4 a. Indexed addressing Modes with Constants Offsets... 4 b. Indexed Addressing Modes with Offset in an Accumulator... 4 c. Auto Pre/Post increment/decrement Indexed Addressing Modes... 5 d. 16-Bit Offset Indexed Indirect Mode... 5 e. Accumulator D Indirect Indexed Addressing A Sample of HCS12 Instructions The LOAD instructions Load Effective Address Instruction The STORE instruction Register to Register Transfer Instructions Exchange Instructions Sign Extension Instructions Memory to Memory Move Instructions The ADD instruction The SUB instruction Shift instructions Programming Examples HCS12 Instructions The HCS12 Machine Code Decoding Machine Language Instructions Instruction Execution Cycle Lecture 3 Addressing Modes Page 1 of 18

2 3.1. Register Transfer Notation () A B X IX M + v ^ Here are examples: A 15 A $15 A ($2015) A A + ($2F) The content of the address specified inside the parenthesis. Transferred to Accumulator A Accumulator B Accumulator A or accumulator B Index register X Memory location Add OR Subtract And The decimal value of 15 is loaded into A. The hexadecimal value of 1516 (2110) is loaded into A. The contents of memory location $2015 is loaded into A. The contents of memory location $2F is added to the contents of A 3.2. HCS12 Addressing Modes An HCS12 instruction consists of 1 or 2 bytes of opcode and 0 to 5 bytes of operand addressing information: The opcode specifies the operation to be performed and the addressing mode used to access the operand. The operand contains the information needed for the operation The addressing mode determines how the CPU accesses registers or memory locations for an instruction to be executed. The HCS12 supports several addressing mode: inherent, immediate, direct, extended, relative, indexed addressing with constants offsets, indexed addressing with Offset in an accumulator, auto pre/post increment/decrement indexed addressing, 16-bit offset indexed indirect mod, and accumulator D indirect indexed addressing. Address and data values are represented in binary format. A large binary number is not practical for human beings to deal with, and therefore, decimal and hexadecimal formats are often used. 1. Inherent Mode (INH) Instructions do not have operands. CLRA Clear the content of the accumulator A Add the content of the accumulator A to the accumulator A ABA and leave the result in the accumulator A Lecture 3 Addressing Modes Page 2 of 18

3 INCA Increment the content of the accumulator A by 1 DECB Decrement the content of the accumulator A by 1 2. Immediate Mode (IMM) The value of the operand is included in the instruction. The immediate value (8-bit or 16- bit) is preceded by # LDAA #22 Load the decimal value of 22 into the accumulator A. ADDA #@32 Add the octal value of 32 to the accumulator A. LDD #$1000 Load the hexadecimal value of 1000 into the accumulator D. Note: # is a prefix that indicates that the operand is actually the data (not address) 3. Direct mode (DIR) This addressing mode is sometimes called zero-page addressing because it is used to access the operands in the address range of $0000 to $00FF. Since the address begin with $0000, only the low byte of the address of the operand need to be included in the instruction. Address of operand operand (low byte) + $0000 (base address of data section) ADDA $10 SUBA $20 LDD $30 Add the value stored at the memory location $0010 to the accumulator A. Subtract from the accumulator A the value stored at the memory location $0020. Load the contents of the memory locations at $0030 and $0031 into double accumulator D. 4. Extended mode (EXT) In the addressing mode, the full 16-bit address (2-byte address) of memory location is included in the instruction Address of operand operand (2-byte) ADDA $1003 LDX $1000 ADDD $1030 Add the value stored at the memory location with the effective address of $1103 to the accumulator A. Load the 16-bit value stored at the memory location with the effective address of $1000 into the index register X. The byte at $1000 will be loaded into the upper byte of X and the byte at $1001 will be loaded into the lower byte of X. Add the 16-bit value stored at the memory location with the effective addresses of $1030 and $1031 to double accumulator D. 5. Relative mode (REL) The relative addressing mode is used only for branch instructions that can change the direction of the program flow. The distance of the branch (or jump) is referred as branch offset. There are short and long conditional branch instructions. Short branch instructions consists of an 8-bit opcode and a signed 8-bit offset ranged from $80 ( 128) to $7F (+127). Lecture 3 Addressing Modes Page 3 of 18

4 Long branch instructions consists of an 8-bit prebyte, an 8-bit opcode, and a signed 16-bit offset contained in 2 bytes following the opcode. The range for long branch instructions is from $8000 ( 32768) to $7FFF (+32676). In the following example, BEQ is a short branch instruction that branches to the label There the condition is met.... BEQ There ADDA #10... There: DECB 6. Indexed Mode (INDEX) In the indexed mode, the effective address of an operand is calculated by adding the base address, which is stored in a base register such as IX, IY, SP, or PC, to the offset. a. Indexed Addressing Modes with Constants Offsets The syntax of the operand of this indexed mode is: n, r where n is a 5-bit, 9-bit, or 16-bit constant r is the base register (IX, IY, SP, or PC) Address of operand constant + [IX, IY, SP, or PC] ADDA LDAA SUBA 10, X 3, Y 0, X Add the value stored at the memory location pointed by the sum of 10 and the contents of the index register X to accumulator A. A [10 + IX] + A Load the contents of the memory location pointed by the sum of 3 and the contents of the index register Y into the accumulator A. A [3 + IY] Subtract the value stored at the memory location pointed by the sum of 0 and the contents of the index register X from the accumulator A. A A [0 + IX] b. Indexed Addressing Modes with Offset in an Accumulator The syntax of the operand of this indexed mode is: acc, r where acc can be A, B, or D r is the base register (IX, IY, SP, or PC) STAA Address of operand [A, B, or D] + [IX, IY, SP, or PC] Store the value in the accumulator A into the memory B, X location pointed by the sum of the accumulator B and the contents of the index register X. Lecture 3 Addressing Modes Page 4 of 18

5 LDAB LDX A, Y D, SP [B + IX] A Load the contents of the memory location pointed by the sum of A and the contents of the index register Y into the accumulator A. A [B + IY] Load two bytes from the memory locations into IX The high byte (MB) from the location [D + SP] The low byte (LB) from the location [1+ D + SP] IX (high byte) [D + SP] IX (low byte) [1 +D + SP] c. Auto Pre/Post increment/decrement Indexed Addressing Modes The syntax of the operand of this indexed mode is: Syntax Effective New Value of Address Base Register r Pre-decrement n, r r n r r n Pre-increment n, +r r + n r r + n Post-decrement n, r r r r n Post-increment n, r+ r r r + n Here are examples. STAA 2, X ADDA 3, +Y LDAB 4, X STAB 8, Y+ IX IX 2 [IX] A IY IY + 3 A A + [IY] B [IX] IX IX 4 [IY] B IY IY + 8 d. 16-Bit Offset Indexed Indirect Mode The syntax of the operand of this indexed mode is: [n, r] where n is 16-bit offset r is the base register (IX, IY, SP, or PC) Here are examples. STAA [2, X] [ [2 + IX] ] A ADDA [3, Y] A A + [ [IY + 3] ] e. Accumulator D Indirect Indexed Addressing The syntax of the operand of this indexed mode is: [D, r] where r is the base register (IX, IY, SP, or PC) Lecture 3 Addressing Modes Page 5 of 18

6 Here are examples. JMP [D, X] Jump to the address [ [D + IX] ] This addressing mode is often used for interrupt vector table A Sample of HCS12 Instructions HCS12 instructions are case-insensitive. Upper case letters or lower case letters are acceptable to the compiler. As a rule of thumb, there is a preferable style which is commonly used: HCS12 Instructions Operands or variables Constant Use upper case letter Use upper case for the first letter, and lower case for the rest of the letters. Use upper case letter 1. The LOAD instructions A group of instructions that place a value or copy the contents of a memory location (or locations) into a register (A, B, D, IX, IY, SP) Mnemonic LDAA <opr> LDAB <opr> LDD <opr> LDS <opr> LDX <opr> LDY <opr> Function Load A Load B Load D Load SP Load index register X Load index register Y Operation A [opr] B [opr] A:B [opr]:[opr+1] SP [opr]:[opr+1] X [opr]:[opr+1] Y [opr]:[opr+1] <opr> can be immediate, direct, extended, or index mode Examples: LDAA $10 LDX #$ Load Effective Address Instruction Mnemonic LEAS <opr> LEAX <opr> LEAY <opr> Function Load effective address into SP Load effective address into X Load efective address into Y Operation SP effective address X effective address Y effective address Load the effective address (n + r), not the content of memory location, into registers (IX, IY, SP) Examples: LEAX B, Y ; IX B + IY LEAY A, Y ; IY A + IY LEAS 4, X ; SP 4 + IX Lecture 3 Addressing Modes Page 6 of 18

7 3. The STORE instruction A group of instructions that store the contents of a register (A, B, D, IX, IY, and SP) into a memory location or memory locations Mnemonic Function Operation STAA <opr> STAB <opr> STD <opr> STS <opr> STX <opr> STY <opr> Store A in a memory location Store B in a memory location Store D in a memory location Store SP in a memory location Store X in a memory location Store Y in a memory location m[opr] [A] m[opr] [B] m[opr]:m[opr+1] [A]:[B] m[opr]:m[opr+1] [SP] m[opr]:m[opr+1] [X] m[opr]:m[opr+1] [Y] <addr> can be direct, extended, or index mode Examples: STAA $20 STAA 10, X STD $10 STD $1000 STD 0, X 4. Register to Register Transfer Instructions TAB Transfer the content of A to B B A TAP Transfer the content of A to CCR CCR A TBA Transfer the content of B to A A B TFR reg1, reg2 Transfer the content of reg1 to reg2 reg2 reg1 TPA Transfer the content of CCR to A A CCR TSX Transfer the content of SP to IX IX SP TSY Transfer the content of SP to IY IY SP TXS Transfer the content of IX to SP SP IX TYS Transfer the content of IY to SP SP IY Examples: TFR A, X ; A is signed-extended to 16 bits and assigned to IX TFR Y, B ; B IY[7:0], B receives lower byte of IY (bits 7:0) 5. Exchange Instructions EXG reg1, reg2 reg1 reg2, exchange the contents of reg1 and reg2 XGDX D IX, exchange the contents of D and IX XGDY D IY, exchange the contents of D and IX Examples: EXG D, X EXG X, A ; D IX ; IX $ A, A X[7:0] Lecture 3 Addressing Modes Page 7 of 18

8 6. Sign Extension Instructions SEX reg1, reg2 reg1 is signed-extended to 16 bits and assigned to reg2 Examples: SEX A, X ; A is signed-extended to 16 bits and assigned to IX SEX CCR, Y ; CCR is signed-extended to 16 bits and assigned to IY 7. Memory to Memory Move Instructions MOVB <src>, <dest> Move a byte (8-bit) from [src] to dest; dest [src] MOVW <src>, <dest> Move a word (16-bit) from [src] to dest; dest [src] Examples: MOVB #$30, $1800 ; [$1800] $30 MOVW Var1, Var2 ; Var2 Var1 MOVW 1, X, 1, Y ; [1 +IY] [1 + IX] 8. The ADD instruction A group of instructions perform addition operation Mnemonic ABA ABX ABY ADCA <opr> ADCB <opr> ADDA <opr> ADDB <opr> ADDD <opr> Function Add B to A Add B to X Add B to Y Add with carry to A Add with carry to B Add without carry to A Add without carry to B Add without carry to D Operation A [A] + [B] X [X] + [B] Y [Y] + [B] A [A] + [opr] + C B [B] + [opr] + C A [A] + [opr] B [B] + [opr] D [D] + [opr] <opr> can be immediate, direct, extended, or index mode Examples: ADDA #10 ; A A + 10 ADDA $20 ; A A + [$ $20] ADDD $FB46 ; D D + [$FB46] 9. The SUB instruction A group of instructions perform subtract operation Mnemonic Function Operation SBA SBCA <opr> SBCB <opr> SUBA <opr> SUBB <opr> SUBD <opr> Subtract B from A Subtract with borrow from A Subtract with borrow from B Subtract memory from A Subtract memory from B Subtract memory from D A [A] - [B] A [A] -[opr] -C B [B] - [opr] - C A [A] - [opr] B [B] - [opr] D [D] - [opr] Lecture 3 Addressing Modes Page 8 of 18

9 <opr> can be immediate, direct, extended, or index mode Examples: SUBA #10 SUBA $10 SUBA 0, X SUBD 10, X 10. Shift Instructions Shift instructions are useful for bit field manipulation. They can be used to speed up the integer multiply and divide operations if one of the operands is a power of 2. The HCS12 has shift instructions that can operate on accumulators A, B, and D or a memory location. A memory operand must be specified using the extended or indexed (direct or indirect) addressing modes. Logical Shift Left LSL <opr> LSLA LSLB memory location <opr> is shifted left one place accumulator A is shifted left one place accumulator B is shifted left one place The operation is LSLD accumulator D is shifted left one place The operation is Logical Shift Right LSR <opr> LSRA LSRB memory location <opr> is shifted right one place accumulator A is shifted right one place accumulator B is shifted right one place The operation is LSRD accumulator D is shifted right one place The operation is Lecture 3 Addressing Modes Page 9 of 18

10 11. Programming Examples Example Compute Y = 7 * X Write an assembly code to compute Y = 7 * X Solution: Register Transfer Notation Arithmetic Assembly Code A X A = X LDAA X B A B = X TAB A 2 * A A = 2 * X LSLA A 2 * A A = 4 * X LSLA A 2 * A A = 8 * X LSLA A A B A = 8 * X X SBA Y A Y = 7 * X STAA Y Alternative solution: Register Transfer Notation Arithmetic Assembly Code A X A = X LDAA X B A B = X TAB B 2 * B B = 2 * X LSLB A A + B A = X + 2 * X = 3 * X ABA B 2 * B B = 4 * X LSLB A A + B A = 3 * X + 4 * X ABA Y A Y = A STAA Y Example Arithmetic Program Design a program that will perform the following computation voltage = 9 * current 25. Solution: ORG $0 ; location of variables current DS.B 1 ; the value of current voltage DS.B 1 ; the value of voltage ; ORG $C000 ; the starting address of the program LDAA current ; A = current TAB ; B = A = current LSLA ; A = 2 * current LSLA ; A = 4 * current LSLA ; A = 8 * current ABA ; A = A + B = 8 * current + current = 9 * current SUBA #25 ; A = 9 * current 25 STAA voltage ; voltage = A = 9 * current 25 SWI END Lecture 3 Addressing Modes Page 10 of 18

11 Example Determine range of Variables In the previous example, given that the voltage and current shall be defined as 1 byte unsigned variables, determine the range of current for which a solution can be computed. (From Dr. Tavora s notes) Constraints: 0 current, voltage all computations 255 Valid range 9* current current current 28 voltage 9* current current current 3 Therefore, 3 current 28 Example Determine range of Variables In the previous example, given that the voltage and current shall be defined as 1 byte signed variables, determine the range of current for which a solution can be computed. (From Dr. Tavora s notes) Constraints: 128 current, voltage all computations 127 Valid range 128 9* current current current voltage 9* current current current 16 Therefore, 11 current HCS12 Instructions Appendix A (pp ) Instruction listing by alphabetical order Lecture 3 Addressing Modes Page 11 of 18

12 Note: Lecture 3 Addressing Modes Page 12 of 18

13 Lecture 3 Addressing Modes Page 13 of 18

14 3.5 The HCS12 Machine Code Each HCS12 instruction consists of 1 to 2 bytes of opcode and 0 to 5 bytes of operand information. These bytes are presented in hexadecimal numbers: Instruction = opcode + operand Opcode specifies the operation to be performed. Operand specifies a value or the address where the value can be found to be used in the operation. Assembly instruction Machine instructions (in hex format) LDAA # D STAA $00 5A 00 ADDA $02 9B 02 STAA $01 5A 01 MOVB $1000, $ C INY Decoding Machine Language Instructions 1. Procedure Compare the first one or two bytes with the opcode table to identify the corresponding assembly mnemonic and format. Identify the operand bytes after the opcode field. Write down the corresponding assembly instruction. Repeat step 1 to 3 until the machine code file is exhausted. Example Decoding Machine Code Decode the following machine code to its corresponding assembly instructions: B 07 5A Solution: The decoding process starts from the leftmost byte. We next look up the machine code table to see which instruction it corresponds to. Instruction 1: The first byte 96 corresponds to the instruction: LDAA DIR. The second byte, 30, is the direct address. Therefore, the first instruction is LDAA $30. Lecture 3 Addressing Modes Page 14 of 18

15 Instruction 2: The third byte (8B) corresponds to the instruction: ADDA IMM. The immediate value is 07. Therefore, the second instruction is ADDA #$07. Instruction 3: The fifth byte (5A) corresponds to the instruction STAA DIR. The DIR address is the next byte 30. Therefore, the third instruction is STAA $30. Instruction 4: The seventh byte (96) corresponds to the instruction LDAA DIR. The DIR value is the next byte 31. Therefore, the four instruction is LDAA $31. Therefore, the equivalent assembly code for the machine code B 07 5A is LDAA $30 ADDA #$07 STAA $30 LDAA $31 Example Decoding Machine Code Decode the following machine code to its corresponding assembly instructions: B 15 C6 12 7C C8 AF Solution: 96 LDAA DIR LDAA $10 5B STAB DIR D7 15 STAB $15 C6 LDAB IMM C6 12 LDAB #$12 7C STD EXT FD C8 AF STD $C8AF Example Decoding Machine Code Decode the following machine code to its corresponding assembly instructions: D A D B C Solution: 86 LDAA IMM LDAA #$12 D6 LDAB DIR D6 10 LDAB $10 54 LSRB ABA 5A STAB DIR STA $12 42 INCA Lecture 3 Addressing Modes Page 15 of 18

16 Example Decoding Machine Code Decode the following machine code to its corresponding assembly instructions: B D C C Solution: B6 LDAA EXT B LDAA $2000 D6 LDAB DIR D6 15 LDAB $ ABA 7C STD EXT FD STD $ INCA INH INCA 48 LSLA INH LSLA 7C STD EXT FD STD $ Instruction Execution Cycle In order to execute a program, the microprocessor or microcontroller must access memory to fetch instructions or operands. The process of accessing a memory location is called a read cycle. The process of storing a value into a memory location is called a write cycle. The process of executing an instruction is called an instruction execution cycle. When executing an instruction, the HCS12 performs a combination of the following operations: One of multiple read cycles to fetch instruction opcode byte(s) and addressing information. One or two read cycles to required to fetch the memory operand(s) The operation specified by the opcode One or two write cycles to write back the result to either a register or a memory location 1. Example Executing Instruction Cycle (assume 8-bit data bus) Consider the following instruction sequence: ORG $C000 LDAA $2000 ADDA $3000 STAA $2000 Assembly Instruction Memory location Opcode LDAA $2000 $C000 B ADDA $3000 $C003 BB STAA $2000 $C006 7A Instruction: LDAA $2000 Step 1. Place the value in PC on the address bus with a request to read the contents of that location. Step 2. The opcode byte $B6 at $C000 is returned to the CPU and PC is incremented by 1. Lecture 3 Addressing Modes Page 16 of 18

17 Step 3. CPU performs two read cycles to obtain the extended address $2000 from locations $C001 and $C002. At the end the value of PC is incremented to $C003. Lecture 3 Addressing Modes Page 17 of 18

18 Step 4. The CPU performs another read to get the contents of the memory location at $2000, which is $19. The value $19 will be loaded into accumulator A. Lecture 3 Addressing Modes Page 18 of 18