University:
California State University, Northridge
Course:
COMP 122/L | Computer Architecture and Assembly Language and Lab
Academic year:

2009
Views:

73

Pages:

58
Author:

Hallie Hurley

Chapter 5 Assembly Language Two types of bit patterns • Instructions ‣ Mnemonics for opcodes ‣ Letters for addressing modes • Data ‣ Pseudo-ops, also called dot commands Figure 5.1 aaa Addressing Mode 000 001 010 011 100 101 110 111 Immediate Direct Indirect Stack-relative Stack-relative deferred Indexed Stack-indexed Stack-indexed deferred Letters i d n s sf x sx sxf Figure 5.2 Instruction Specifier Mnemonic Instruction Addressing Modes 0000 0000 0000 0001 0000 0010 0000 0011 STOP RETTR MOVSPA MOVFLGA Stop execution Return from trap Move SP to A Move NZVC flags to A U U U U 0000 010a 0000 011a 0000 100a 0000 101a 0000 110a 0000 111a 0001 000a 0001 001a 0001 010a 0001 011a BR BRLE BRLT BREQ BRNE BRGE BRGT BRV BRC CALL Branch unconditional Branch if less than or equal to Branch if less than Branch if equal to Branch if not equal to Branch if greater than or equal to Branch if greater than Branch if V Branch if C Call subroutine i, x i, x i, x i, x i, x i, x i, x i, x i, x i, x 0001 100r 0001 101r 0001 110r 0001 111r 0010 000r 0010 001r NOTr NEGr ASLr ASRr ROLr RORr Bitwise invert r Negate r Arithmetic shift left r Arithmetic shift right r Rotate left r Rotate right r U U U U U U Status Bits NZ NZV NZVC NZC C C 0000 100a 0000 101a 0000 110a 0000 111a 0001 000a 0001 001a 0001 010a 0001 011a BRLT BREQ BRNE BRGE BRGT BRV BRC CALL Branch if less than Branch if equal to Branch if not equal to Branch if greater than or equal to Branch if greater than Branch if V Branch if C Call subroutine i, x i, x i, x i, x i, x i, x i, x i, x 0001 100r 0001 101r 0001 110r 0001 111r 0010 000r 0010 001r NOTr NEGr ASLr ASRr ROLr RORr Bitwise invert r Negate r Arithmetic shift left r Arithmetic shift right r Rotate left r Rotate right r U U U U U U 0010 01nn 0010 1aaa NOPn NOP Unary no operation trap Nonunary no operation trap U i 0011 0aaa 0011 1aaa 0100 0aaa 0100 1aaa 0101 0aaa DECI DECO STRO CHARI CHARO Decimal input trap Decimal output trap String output trap Character input Character output d, n, s, sf, x, sx, sxf i, d, n, s, sf, x, sx, sxf d, n, sf d, n, s, sf, x, sx, sxf i, d, n, s, sf, x, sx, sxf 0101 1nnn RETn Return from call with n local bytes U 0110 0aaa 0110 1aaa ADDSP SUBSP Add to stack pointer (SP) Subtract from stack pointer (SP) i, d, n, s, sf, x, sx, sxf i, d, n, s, sf, x, sx, sxf NZVC NZVC 0111 raaa 1000 raaa 1001 raaa 1010 raaa 1011 raaa ADDr SUBr ANDr ORr CPr Add to r Subtract from r Bitwise AND to r Bitwise OR to r Compare r i, d, n, s, sf, x, sx, sxf i, d, n, s, sf, x, sx, sxf i, d, n, s, sf, x, sx, sxf i, d, n, s, sf, x, sx, sxf i, d, n, s, sf, x, sx, sxf NZVC NZVC NZ NZ NZVC Figure 5.2 (Continued) NZ NZV NZVC NZC C C NZV 0010 01nn 0010 1aaa NOPn NOP Unary no operation trap Nonunary no operation trap U i 0011 0aaa 0011 1aaa 0100 0aaa 0100 1aaa 0101 0aaa DECI DECO STRO CHARI CHARO Decimal input trap Decimal output trap String output trap Character input Character output Figure 5.2NZV d, n, s, sf, x, sx, sxf i, d, n, s, sf, x, sx,(Continued) sxf d, n, sf d, n, s, sf, x, sx, sxf i, d, n, s, sf, x, sx, sxf 0101 1nnn RETn Return from call with n local bytes U 0110 0aaa 0110 1aaa ADDSP SUBSP Add to stack pointer (SP) Subtract from stack pointer (SP) i, d, n, s, sf, x, sx, sxf i, d, n, s, sf, x, sx, sxf NZVC NZVC 0111 raaa 1000 raaa 1001 raaa 1010 raaa 1011 raaa ADDr SUBr ANDr ORr CPr Add to r Subtract from r Bitwise AND to r Bitwise OR to r Compare r i, d, n, s, sf, x, sx, sxf i, d, n, s, sf, x, sx, sxf i, d, n, s, sf, x, sx, sxf i, d, n, s, sf, x, sx, sxf i, d, n, s, sf, x, sx, sxf NZVC NZVC NZ NZ NZVC 1100 raaa 1101 raaa 1110 raaa 1111 raaa LDr LDBYTEr STr STBYTEr Load r from memory Load byte from memory Store r to memory Store byte r to memory i, d, n, s, sf, x, sx, sxf i, d, n, s, sf, x, sx, sxf d, n, s, sf, x, sx, sxf d, n, s, sf, x, sx, sxf NZ NZ The unimplemented opcode instructions • NOPn • NOP • DECI • DECO • STRO Unary no operation trap Nonunary no operation trap Decimal input trap Decimal output trap String output trap Pseudo-operations • .ADDRSS • .ASCII • .BLOCK • .BURN • .BYTE • .END • .EQUATE • .WORD The address of a symbol A string of ASCII bytes A block of bytes Initiate ROM burn A byte value The sentinel for the assembler Equate a symbol to a constant value A word value (two bytes) Figure 5.3 Assembler Input ;Stan Warford ;January 13, 2009 ;A program to output "Hi" ; CHARO 0x0007,d ;Output 'H' CHARO 0x0008,d ;Output 'i' STOP .ASCII "Hi" .END Assembler Output 51 00 07 51 00 08 00 48 69 zz Program Output Hi Figure 5.4 7 Application level 6 High-order language level 5 Assembly level 4 Operating system level 3 Instruction set architecture level 2 Microcode level 1 Logic gate level Figure 5.5 Input CHARO CHARO STOP .ASCII .END 0x0007,d 0x0008,d "Hi" Processing Output Assembler 51 00 07 51 00 08 00 48 69 zz Figure 5.6 Assembler Input CHARI CHARI CHARO CHARO STOP .BLOCK .BLOCK .END 0x000D,d 0x000E,d 0x000E,d 0x000D,d ;Input first character ;Input second character ;Output second character ;Output first character 1 1 ;Storage for first char ;Storage for second char Assembler Output 49 00 0D 49 00 0E 51 00 0E 51 00 0D 00 00 00 zz Program Input up Program Output pu Figure 5.7 Assembler Input LDA ADDA ORA STBYTEA CHARO STOP .BLOCK .WORD .WORD .WORD .END 0x0011,d 0x0013,d 0x0015,d 0x0010,d 0x0010,d ;A <- first number ;Add the two numbers ;Convert sum to character ;Store the character ;Output the character 1 5 3 0x0030 ;Character to output ;Decimal 5 ;Decimal 3 ;Mask for ASCII char Assembler Output C1 00 11 71 00 13 A1 00 15 F1 00 10 51 00 10 00 00 00 05 00 03 00 30 zz Program Output 8 Figure 5.8 Input Processing Output Application (assembly language) Assembler (machine language) Application (machine language) up Application (machine language) pu Figure 5.9 Assembler Input chari 0x000D,d ;Input first character CHARI 0x000E,d ;Input second character charo 0x000E, d ;Output second character CHarO 0x000D,D ;Output first character stop .bloCK 1 ;Storage for first char .BLOCK 1 ;Storage for second char .END Assembler Listing Addr 0000 0003 0006 0009 000C 000D 000E 000F Object code 49000D 49000E 51000E 51000D 00 00 00 Mnemon CHARI CHARI CHARO CHARO STOP .BLOCK .BLOCK .END Operand 0x000D,d 0x000E,d 0x000E,d 0x000D,d Comment ;Input first character ;Input second character ;Output second character ;Output first character 1 1 ;Storage for first char ;Storage for second char Direct addressing • Oprnd = Mem[OprndSpec] • Asmb5 letter: d • The operand specifier is the address in memory of the operand. Immediate addressing • Oprnd = OprndSpec • Asmb5 letter: i • The operand specifier is the operand. Figure 5.10 0000 0003 0006 0007 500048 CHARO 500069 CHARO 00 STOP .END Output Hi 'H',i 'i',i ;Output 'H' ;Output 'i' The decimal input instruction • Instruction specifier: 0011 0aaa • Mnemonic: DECI • Convert a string of ASCII characters from the input device into a 16-bit signed integer and store it into memory Oprnd ← {decimal input} The decimal output instruction • Instruction specifier: 0011 1aaa • Mnemonic: DECO • Convert a 16-bit signed integer from memory into a string of ASCII characters and send the string to the output device {decimal output} ← Oprnd The unconditional branch instruction • Instruction specifier: 0000 010a • Mnemonic: BR • Skips to a different memory location for the next instruction to be executed. PC ← {Oprnd} Figure 5.11 0000 0003 0005 0008 000B 000E 0011 0014 0017 001A 001D 0020 0023 0026 0029 002C 002D 040005 BR 0000 .BLOCK ; 310003 DECI 390003 DECO 500020 CHARO 50002B CHARO 500020 CHARO 500031 CHARO 500020 CHARO 50003D CHARO 500020 CHARO C10003 LDA 700001 ADDA E10003 STA 390003 DECO 00 STOP .END Input -479 Output -479 + 1 = -478 0x0005 2 ;Branch around data ;Storage for one integer 0x0003,d 0x0003,d ' ',i '+',i ' ',i '1',i ' ',i '=',i ' ',i 0x0003,d 1,i 0x0003,d 0x0003,d ;Get the number ;and output it ;Output " + 1 = " ;A <- the number ;Add one to it ;Store the sum ;Output the sum The string output instruction • Instruction specifier: 0100 0aaa • Mnemonic: STRO • Send a string of null-terminated ASCII characters to the output device {string output} ← Oprnd Figure 5.12 0000 0003 0005 000D 0010 0013 0016 0019 001C 001F 0022 0023 04000D BR 0000 .BLOCK 202B20 .ASCII 31203D 2000 ; 310003 DECI 390003 DECO 410005 STRO C10003 LDA 700001 ADDA E10003 STA 390003 DECO 00 STOP .END Input -479 Output -479 + 1 = -478 0x000D ;Branch around data 2 ;Storage for one integer " + 1 = \x00" 0x0003,d 0x0003,d 0x0005,d 0x0003,d 1,i 0x0003,d 0x0003,d ;Get the number ;and output it ;Output " + 1 = " ;A <- the number ;Add one to it ;Store the sum ;Output the sum Interpreting bit patterns • Dot commands set bit patterns at assembly time • Executable statements interpret bit patterns at run time Figure 5.13 0000 0003 0005 0006 0007 040009 FFFE 00 55 0470 0009 000C 000F 0012 0015 0018 001B 001C 390003 50000A 390005 50000A 510006 510008 00 Output -2 85 Up BR .WORD .BYTE .BYTE .WORD ; DECO CHARO DECO CHARO CHARO CHARO STOP .END 0x0009 0xFFFE 0x00 'U' 1136 ;Branch around data ;First ;Second ;Third ;Fourth 0x0003,d '\n',i 0x0005,d '\n',i 0x0006,d 0x0008,d ;Interpret First as decimal ;Interpret Second and Third as decimal ;Interpret Third as character ;Interpret Fourth as character Disassembler • The inverse mapping of an assembler is not unique • Given a bit pattern at level ISA3, you cannot determine the Asmb5 statement that produced it Figure 5.14 Assembly Language Program 0000 0003 0006 0009 000A 000D 51000A 51000B 51000C 00 50756E CHARO CHARO CHARO STOP .ASCII .END 0x000A,d 0x000B,d 0x000C,d "Pun" Assembly Language Program 0000 0003 0006 0009 000A 000D 51000A 51000B 51000C 00 50756E CHARO CHARO CHARO STOP CHARO .END Program Output Pun 0x000A,d 0x000B,d 0x000C,d 0x756E,i Mappings • The mapping from Asmb5 to ISA3 is one-toone • The mapping from HOL6 to Asmb5 is oneto-many Symbols • Defined by an identifier followed by a colon at the start of a statement • The value of a symbol is the address of the object code generated by the statement Figure 5.15 Assembler Listing Addr 0000 0003 0005 000D 0010 0013 0016 0019 001C 001F 0022 0023 Object code Symbol 04000D 0000 num: 202B20 msg: 31203D 2000 ; 310003 main: 390003 410005 C10003 700001 E10003 390003 00 Symbol table: Symbol Value main 000D num 0003 Mnemon Operand BR .BLOCK .ASCII main ;Branch around data 2 ;Storage for one integer " + 1 = \x00" DECI DECO STRO LDA ADDA STA DECO STOP .END num,d num,d msg,d num,d 1,i num,d num,d Symbol msg Value 0005 Comment ;Get the number ;and output it ;Output ' + 1 = ' ;A := the number ;Add one to it ;Store the sum ;Output the sum Figure 5.15 (Continued) Input -479 Output -479 + 1 = -478 Figure 5.16 Assembler Input this: DECO this,d STOP .END Assembler Listing 0000 0003 0004 390000 this: 00 Output 14592 DECO STOP .END this,d Figure 5.17 7 Application level Application level 6 High-order language level High-order language level 5 Assembly level Assembly level 4 Operating system level Operating system level 3 Instruction set architecture level Instruction set architecture level 2 Microcode level Microcode level 1 Logic gate level Logic gate level (a) Translation directly to machine language. (b) Translation to assembly language. Translating cout • Translate string output with STRO • Translate character output with CHARO • Translate integer output with DECO Figure 5.18 High-Order Language #include using namespace std; int main () { cout << "Love" << endl; return 0; } Assembly Language 0000 0003 0006 0007 410007 50000A 00 4C6F76 msg: 6500 000C Output Love STRO CHARO STOP .ASCII .END msg,d '\n',i "Love\x00" Figure 5.19 Input #include using namespace std; int main () { cout << "Love" << endl; return 0; } Processing Compiler Output 41 00 07 50 00 0A 00 4C 6F 76 65 00 zz (a) A compiler that translates directly into machine language. #include using namespace std; int main () { cout << "Love" << endl; return 0; } Compiler msg: (b) A compiler that translates into assembly language. STRO msg,d CHARO '\n',i STOP .ASCII"Love\x00" .END ory ss o Figure 5.20 C++ identifier for variable name Memory address (a) A compiler that translates to machine language. C++ identifier for variable name Pep/8 assembly language symbol C++ identifier for variable nam (b) A hypotheti Memory address (b) A hypothetical compiler for illustrative purposes. Global variables • Allocated at a fixed location in memory with .BLOCK • Accessed with direct addressing (d) Assignment statements • Load the accumulator from the right hand side of the assignment with LDA • Compute the value of the right hand side of the assignment if necessary • Store the value to the variable on the left hand side of the assignment with STA Figure 5.21 High-Order Language #include using namespace std; char ch; int j; int main () { cin >> ch >> j; j += 5; ch++; cout << ch << endl << j << endl; return 0; } Figure 5.21 (Continued) Assembly Language 0000 0003 0004 0006 0009 000C 000F 0012 0015 0018 001B 001E 0021 0024 0027 002A 002B 040006 00 ch: 0000 j: ; 490003 main: 310004 C10004 700005 E10004 D10003 700001 F10003 510003 50000A 390004 50000A 00 BR .BLOCK .BLOCK main 1 2 CHARI DECI LDA ADDA STA LDBYTEA ADDA STBYTEA CHARO CHARO DECO CHARO STOP .END ch,d j,d j,d 5,i j,d ch,d 1,i ch,d ch,d '\n',i j,d '\n',i ;global variable #1c ;global variable #2d ;cin >> ch ; >> j ;j += 5 ;ch++ ;cout << ch ; << endl ; << j ; << endl Figure 5.21 (Continued) Input M 419 Output N 424 Figure 5.22 #include using namespace std; char ch; int j; int main () { cin >> ch >> j; j += 5; ch++; cout << ch << endl << j << endl; return 0; } symbol value kind [0] ch 0003 sChar [1] j 0004 sInt [2] Figure 5.23 #include using namespace std; int j; float y; int main () { ... j = j % 8; ... y = y % 8; // Compile error ... } symbol value kind [0] j 0003 sInt [1] y 0005 sFloat [2] Trace tags • Format trace tags ‣ Required for global and local variables • Symbol trace tags ‣ Not required for global variables Format trace tags • #1c • #1d • #2d • #1h • #2h One-byte character One-byte decimal Two-byte decimal One-byte hexadecimal Two-byte hexadecimal The arithmetic shift right instruction • Instruction specifier: 0001 111r • Mnemonic: ASRr (ASRA, ASRX) • Performs a one-bit arithmetic shift right on a 16-bit register C ← r"15# , r"1..15# ← r"0..14#; N←r<0, Z←r=0 Figure 5.24, 5.25 Instruction specifier Opcode r 0 0 0 1 1 1 1 0 1 E CPU CPU NZC A (a) Before 0098 1E Arithmetic shift right accumulator NZC A (b) After 000 004C The arithmetic shift left instruction • Instruction specifier: 0001 110r • Mnemonic: ASLr (ASLA, ASLX) • Performs a one-bit arithmetic shift left on a 16-bit register C ← r"0# , r"0..14# ← r"1..15# , r"15# ← 0 ; N ← r < 0 , Z ← r = 0 , V ← {overflow} The rotate left instruction • Instruction specifier: 0010 000r • Mnemonic: ROLr (ROLA, ROLX) • Performs a one-bit rotate left on a 16-bit register C ← r"0# , r"0..14# ← r"1..15# , r"15# ← C ; The rotate right instruction • Instruction specifier: 0010 001r • Mnemonic: RORr (RORA, RORX) • Performs a one-bit rotate right on a 16-bit register C ← r"15# , r"1..15# ← r"0..14# , r"0# ← C ; Constants • Equate the constant to its value with .EQUATE • .EQUATE does not generate object code • The value of the constant symbol is not an address Figure 5.26 High-Order Language #include using namespace std; const int bonus = 5; int exam1; int exam2; int score; int main () { cin >> exam1 >> exam2; score = (exam1 + exam2) / 2 + bonus; cout << "score = " << score << endl; return 0; } Figure 5.26 (Continued) Assembly Language 0000 0003 0005 0007 0009 000C 000F 0012 0015 0016 0019 001C 001F 0022 0025 0026 002F 040009 bonus: 0000 exam1: 0000 exam2: 0000 score: ; 310003 main: 310005 C10003 710005 1E 700005 E10007 410026 390007 50000A 00 73636F msg: 726520 3D2000 BR .EQUATE .BLOCK .BLOCK .BLOCK main 5 2 2 2 DECI DECI LDA ADDA ASRA ADDA STA STRO DECO CHARO STOP .ASCII exam1,d exam2,d exam1,d exam2,d .END bonus,i score,d msg,d score,d '\n',i "score = \x00" ;constant ;global variable #2d ;global variable #2d ;global variable #2d ;cin >> exam1 ; >> exam2 ;score = (exam1 ; + exam2) ; / 2 ; + bonus ;cout << "score = " ; << score ; << endl Figure 5.26 (Continued) Symbol table: Symbol Value bonus 0005 exam2 0005 msg 0026 Input 68 84 Output score = 81 Symbol exam1 main score Value 0003 0009 0007 Figure 5.27 Assembly Language 0000 0003 0006 0009 000C 000D 0010 0013 0016 0019 001C 001D 001F 0021 0023 002C 31001D main: 31001F C1001D 71001F 1E 700005 E10021 410023 390021 50000A 00 ; bonus: 0000 exam1: 0000 exam2: 0000 score: 73636F msg: 726520 3D2000 DECI DECI LDA ADDA ASRA ADDA STA STRO DECO CHARO STOP exam1,d exam2,d exam1,d exam2,d .EQUATE .BLOCK .BLOCK .BLOCK .ASCII 5 ;constant 2 ;global variable #2d 2 ;global variable #2d 2 ;global variable #2d "score = \x00" .END bonus,i score,d msg,d score,d '\n',i ;cin >> exam1 ; >> exam2 ;score = (exam1 ; + exam2) ; / 2 ; + bonus ;cout << "score = " ; << score ; << endl Figure 5.28 Input Run 1 Processing Output A E Run 2 F Run 3 G Run 4 H

Assembly Language

of 58

Description

Free up your schedule!

Take 5 seconds to unlock