Monday, February 11, 2013

Transcription

1 Monday, February 11, 2013 Topics for today The Pep/8 memory Four example programs The loader The assembly language level (Chapter 5) Symbolic Instructions Assembler directives Immediate mode and equate Location of variables in a program Trap instructions Symbols in Pep/8 Math operations in Pep/8 Compilers and Assemblers Making Assembly Code Readable Example translations from high-level language The Pep/8 memory Diagrams in the book (eg Fig 437) can be misleading as to the relative sizes of various sections of the Pep/8 memory For example, from Fig 437 you might think the area available for Application Programs and the area used by the Operating System are about the same size Here is a summary of the memory Application Program Area Address Range 0FBCE 16 (064462) Contents About 98% of the memory! In this area is the user program and the runtime stack The user program occupies bytes 0 onwards and the stack grows upwards toward the user program The stack typically grows and shrinks as the program runs It is possible for the stack to run into and overwrite the user program Operating System Area FBCFFC56 16 ( ) FC47FFFF 16 ( ) RAM - Here is the variable part of the operating system: The system stack (128 bytes) and the I/O buffer (108 bytes) ROM - Here is the unchanging part of the operating system: the loader (about 64 bytes), the trap handler (about 863 bytes) and pointers to (a) base of user stack, (b) I/O buffer, (c) start of loader, (d) start of trap handler Comp 162 Notes Page 1 of 19 February 11, 2013

2 Four Example programs We look at four example programs from the book to get an idea of how the Pep/8 machine operates Once we get to Chapter 5, we will abandon machine code programming Example 1: Fig 432 This is a very simple program The instruction to output a character has first byte followed by a two-byte operand Here is how the first byte is interpreted opcode mode In general, an addressing mode tells the CPU how to use the two-byte number that follows the opcode byte When mode= 001 the number is treated as the address of the operand At this point in our look at low-level programming, the programmer has to figure out addresses of data locations (this will change when we get to Chapter 5) This program outputs Hi with the ASCII codes for H and i in the two bytes following the STOP instruction Example 2: Figure 434 Uses the character input instruction which has first byte opcode mode We read from the input device (can be either the keyboard or the active window) into the memory There is no way to read data directly from an external source directly into a register Note that the data locations here are further down memory than those in Fig 432 because we have more room taken up by instructions This program uses two memory locations to store characters from input then outputs them in reverse order Example 3: Figure 435 This program adds two constants (3,5) then outputs their sum The program has to convert the result of the sum (0008) into the ASCII code for 8 (which is 0038) It does the conversion by OR-ing the register with 30(hex) Clearly program is not very general and will not work if the sum > 9 Comp 162 Notes Page 2 of 19 February 11, 2013

3 Example 4: Figure 436: a self-modifying program Address Contents 0 D D 3 F C A 00 B 19 The first two instructions of the program get a byte (81) from location 1D (hex) and store it in location 9 Byte 9 is the opcode byte of the 4 th instruction of the program The effect of the modification is to change the 4 th instruction from an Add (opcode byte 71) to a Sub (opcode byte 81) instruction Now instead of adding data locations containing 5 and 3, it subtracts 3 from 5 Not very interesting but it does demonstrate that the program code is not "write protected" in any way (In contrast, part of the operating system is write-protected and cannot be modified by a user program) We can imagine a more interesting program that (1) is interactive - letting the user input the new opcode or (2) changes an operand rather than an opcode so that the address on which the instruction operates is changed The loader One of the built-in utilities in the Pep/8 system is a facility to load a program (written in hex) into memory Example in Fig 441 shows the format required for a file that is to be loaded The loader is a very simple program it is listed in Fig 83 if you are interested The loader is fussy about the form of the input (1) between hex numbers is a single space or a newline (2) program is terminated with zz We can write programs in hexadecimal and have the Pep/8 system run them The three steps involved are as follows (may be different for different versions of Pep/8): Comp 162 Notes Page 3 of 19 February 11, 2013

4 (1) Enter your hex program in the Object Code window remembering the loader conventions above (2) If the program inputs data from the user then above the Input window, select tab to Terminal I/O (3) Under Build select Run Object This will load your program into the Pep/8 memory and if that succeeds, will execute the program You can see that writing programs in hex is tedious and error prone Hex programs are difficult to write, to edit, to read and to debug So two of the earliest developments in computing (back in the 1950s) were symbolic languages (assembly code) translators (assemblers) from assembly code to machine code Warford s Chapter 5 looks at symbolic programming and the way in which assemblers work Chapter 5 In Chapter 5, Warford moves up a level in the multi-level machine to the assembly language level Assembly code enables programs to be written using symbols instead of numbers Some advanced assembly languages have features similar to those in high-level languages (loops and if constructs) Compared with high-level language programs, assembly code programs have a relatively simple structure Possibly because early systems used punched cards for input, a typical assembly language is line-oriented, ie, not free-form like a high-level language Each line is one of three types * a symbolic machine language instruction (maybe with commentary) * commentary only * an assembler directive or "pseudo operation" The Assembler - so called because it assembles the pieces of program - translates symbols to numbers and outputs an object program The order of items in the object program may be different from their order in the source program Comp 162 Notes Page 4 of 19 February 11, 2013

5 Source Program Assembler Object Program In some Pep/8 systems, source programs have a pep extension and object files have a pepo extension (1) Symbolic instructions The typical format of a symbolic instruction (with optional components shown in square brackets) is: [ label ] opcode [operands] [ ; commentary ] Examples LOOP: LDA 0,i ; initialize counter BRGE END ; branch if sum > 0 STOP NEXT: ASLA ; now double it The following are typical symbolic instructions in the Pep/8 assembly language: LDA 0,i STRO Mesg4,d CHARO '\n',i CPA 0x3F1E,i STOP The table in Fig 52 is an expanded version of the table in Fig 46 It lists the instructions available to assembly language programmers In addition to the binary Instruction Specifier that we saw in Chapter 4, the table shows for each instruction, (1) the Mnemonic (symbolic opcode) that the assembler recognizes (2) whether the instruction is unary (one byte long) or non-unary (three bytes long) (3) which addressing modes are legal to use with this instruction (4) which of the four status bits might be changed (if any) by the action of the instruction Comp 162 Notes Page 5 of 19 February 11, 2013

6 If you compare Fig 52 with Fig 46 you will see there are a few subtle changes The five instructions listed as unimplemented opcode in chapter 4 now appear either as high-level input/output (deco, deci, stro) or as no-operation trap instructions (nop, nopn) (2) Comments In Pep/8, any text between semi-colon and end of line is commentary, thus ; this line is just comment ; the following instruction has commentary lda M,d ; get count of lines to output Writing good comments in a program is an art more on this later (3) Assembler directives / "Pseudo operations" An assembler directive is just an instruction to the assembler (translation program) to perform some action at assembly (translation) time In assembly languages it is a common convention for such directives to begin with a period, ie xxx yyy This makes it easy for the assembler to distinguish them from symbolic machine instructions These directives are sometimes called "pseudo operations" (Warford uses this term) because (apart from the period) they look like symbolic machine operations but are not really There is a list of the Pep/8 pseudo operations on Page 194 Most of them are concerned with reserving space in the program for data locations Thus we have block N word A byte B ascii/abcdefg/ ; reserve N bytes of space ; reserve a word initialized to A ; reserve a byte initialized to B ; initialize bytes with sequence of characters There is also which every program must have It marks the physical end of the source program the assembler does not read beyond this line Here are some approximate equivalencies between declarations in a high-level declarations and pseudo operations in Pep/8 Comp 162 Notes Page 6 of 19 February 11, 2013

7 int A; A: block 2 char B; B: block 1 int C = 50; C: word 50 char D = '%'; char E[] = "xyz"; D: byte '%' E: ascii xyz byte 0 OR E: ascii xyz\x00 int F [30]; F: block 60 char G [25]; G: block 25 In the case of string xyz, the extra zero byte ( \x00 ) acts as a string terminator used by the stro instruction Example Assembly code program The program in Fig 53 outputs Hi (without the quotes) to the screen CHARO 0x0007,d ;Output 'H' CHARO 0x0008,d ;Output 'i' STOP ASCII "Hi" END We will see later that other features of the assembly language let us improve on this program Note that END is the very last line and the STOP after the two instructions s the program and prevents it from running into the data Immediate Mode (see section 52) It is not necessary to have immediate mode Consider the following program that inputs a number then outputs the number that is 5 greater than the number input deci N,d ; get a number lda N,d ; load it into Register A adda five,d ; add the contents of a location containing 5 sta N,d ; overwrite the original number deco N,d ; and output updated quantity N: block 2 ; space for the number five: word 5 ; a location containing 5 Comp 162 Notes Page 7 of 19 February 11, 2013

8 We can store all constants that the program needs in their own memory locations like this But it is shorter (and a little faster) if we are able to use the number 5 as part of an instruction as in the following: deci N,d lda N,d adda 5,i ; add 5 to register immediate mode sta N,d deco N,d N: block 2 The ",i" in the adda instruction indicates immediate mode It indicates that 5 is the operand itself Contrast this with lda 5,d ; add contents of word at memory location 5 The ",d" here indicates direct mode - the 5 is the address of the operand (which must therefore be fetched using an additional read) Immediate mode is faster because we have one fewer memory read The equate directive Consider the following program fragment ; Program A lda limit,d cpx limit,d suba limit,d limit: word 19 Perhaps it is part of a registration program and the variable "limit" holds the largest number of units that a student can register for The following program (B) using immediate mode runs faster ; Program B lda 19,i cpx 19,i suba 19,i Comp 162 Notes Page 8 of 19 February 11, 2013

9 But program B has two disadvantages: (1) if we need to change the limit we have multiple edits to make; we may miss one and make the program inconsistent (2) the constant 19 appearing in the program does not indicate what it represents A solution that combines the readability and editability of program A with the speed of program B is the following ; Program C limit: equate 19 lda limit,i cpx limit,i suba limit,i The equate directive lets us associate a symbolic name with a value After assembly, programs B and C are identical Location of variable declarations Where do variables go in an assembly language program? To a certain extent it is a matter of programming style but we have to be sure that program execution cannot run into them Two possibilities are: (1) after STOP and before END <executable instructions go here> ; program will halt at this line A: word 3 B: block 4 C: word 17 (2) at the beginning of the program in which case we need to skip over them and have something like br main ; transfer control to instruction labeled main a: block 2 b: block 2 main: <first executable instruction> The br (branch) instruction does an unconditional transfer of control to the specified location Warford prefers style (2) in his example programs Comp 162 Notes Page 9 of 19 February 11, 2013

10 Here are four translations of the following pseudocode program int a=30, b=25, c; c = a+b; output (c); Two of the translations have errors Which? Program 1 Program 2 Program 3 Program 4 adda b,d sta c,d deco c,d a: word 30 b: word 25 c: block 2 a: word 30 b: word 25 c: block 2 adda b,d sta c,d deco c,d br main a: word 30 b: word 25 c: block 2 main: adda b,d sta c,d deco c,d adda b,d sta c,d deco c,d a: word 30 b: word 25 c: block 2 Program 1: is correct Program 2: halts at byte 0 when the program tries to execute a data location Program 3: is correct Program 4: fails to assemble because the assembler does not read anything after so does not see the definitions of symbols a, b and c Trap Instructions Instruction DECO, DECI and STRO exist at the assembly language level but not at the machine language level So what happens when the system encounters one during the running of a program? Answer - the system springs a "trap" which takes the following form (see Fig 439) - the user program is suspended - important data areas are saved on the system stack (registers, status bits) - control is transferred to the Trap Handler in the operating system - the operating system code takes appropriate action depending on the particular instruction Comp 162 Notes Page 10 of 19 February 11, 2013

11 - the data saved is restored - control is returned to the user program using the RETTR (return from trap) instruction Thus these three instructions are very slow compared with non-trap instructions Here is what appropriate action" means for the various instructions: DECI: uses CHARI to input characters Checks they form a legal integer Outputs an Error message if invalid characters are input DECO: converts number to string of digit characters, uses CHARO to output them STRO: uses CHARO to output a null-terminated string of characters Recall that we can set up a string in memory using the ascii directive How does STRO know the length of the string Pep/8 could use one of two ways: (a) a byte at the beginning of the string indicating length (b) an end-of-string marker It uses method (b) and the ASCII NUL byte (code 0) as the marker This is the same method that C uses to delimit strings We can set up a null-terminated string a couple of different ways msg: ascii "message" byte 0 or simply msg: ascii "message\x00" There are very few situations where a programmer needs to be aware that an instruction is a trapped instruction rather than a normal instruction In addition to the three instructions above, NOP and NOPa are also trapped These are no operation instructions; sometimes it is useful to have an instruction that doesn t do anything! Symbols in Pep/8 Identifiers: follow usual identifier rules (start with a letter, continue with letters, underscore or digits) but in Pep/8 they can be no more than 8 chars long Many assembly languages have similar length restrictions Pep/8 will give an error message rather than just using the first 8 characters longername: block 2;ERROR: Symbol longername cannot have more than eight characters Numbers: can be decimal 1234 or hex 0xFF8E (The hex notation is similar to some high-level languages) Comp 162 Notes Page 11 of 19 February 11, 2013

12 Characters: eg '*' (single quotes) '\n' '\t' '\x00' Strings: eg "Output follows\n" (double quotes) Ultimately, everything is bits We can manipulate the contents of memory in nonstandard ways Consider the following program this: stro this,d When run, this program outputs A Why? The translation of the program is When it runs it outputs the string starting at location 0 that terminates with a null (zero) bytes The first two bytes of the program in hex are The ASCII code for A is 41 (hex) Consider also the following self-modifying program that we saw a version of earlier ldbytea 0x70,i stbytea X,d lda 8,i X: suba 3,i sta N,d deco N,d N: block 2 When it runs, the program modifies the byte at X This is the opcode byte of the 4th instruction It changes it from 80 (SUB) to 70 (ADD) so the program outputs 11 not 5 Math operations in Pep/8 Multiplication If we are multiplying by a power of 2 then we just need a sequence of left shifts Thus, to compute N * 8 lda N,d asla asla asla Comp 162 Notes Page 12 of 19 February 11, 2013

13 In general we can accomplish multiplication using shifting and adding The following sequence computes M * 29 [ 29 is 11101, can you see a general pattern here? ] Division lda M,d ; M asla ; M * 2 adda M,d ; M * 3 asla ; M * 6 adda M,d ; M * 7 asla ; M * 14 asla ; M * 28 adda M,d ; M * 29 We can easily compute X/Y if Y is a power of 2 using right shifts If Y is not a power of 2, the required program is more complex For example, to compute P/16 lda P,d asra asra asra asra Modulus We can easily compute P%Q if P is positive and Q is a power of 2 For example the result if T % 8 is the rightmost 3 bits of T thus lda T,d anda 7,i In general, it is more difficult as the following table illustrates M N M%N M&(N-1) Comp 162 Notes Page 13 of 19 February 11, 2013

14 Simple arithmetic and assignment statement High-level language: M = N * 8 + T; Pep/8: lda N,d asla asla asla adda T,d sta M,d Compilers and Assemblers Both compilers and assemblers are translation programs Both use symbol tables but the compiler symbol table has to record information such as type and scope of the identifiers Compiler does type checking that an assembler does not do ( everything is bits ) Making Assembly Code Readable It is important to augment the source code of a program with commentary that lets a reader know what the program does and how it does it The key is to explain why an action is being taken rather than what the action is (the instruction already tells us what the action is) Consider the following two versions of a Pep/8 program to print a triangle of stars such as **** *** ** * The algorithm is Read(numrows) Repeat { Output Numrows stars Output a newline numrows = numrows -1; } until numrows=0 Comp 162 Notes Page 14 of 19 February 11, 2013

15 Version 1 deci m,d ; input m top: lda m,d sta n,d ; n = m top2: charo '*',i ; output a star lda n,d suba 1,i sta n,d ; n = n - 1 brne top2 ; inner loop charo '\n',i ; output a newline lda m,d suba 1,i sta m,d ; m = m - 1 brne top ; outer loop n: block 2 m: block 2 Here, the comments add little to our understanding of the program In many cases they just replicate the instruction A good comment will explain why an action is being done There is also room for improvement in the choice of identifiers and in adding a prompt when input is requested Version 2 ; program inputs m then prints a triangle of stars with ; m rows of stars The first row has m stars, the second ; has m-1 stars, the third has m-2 stars and so on ; stro prompt,d deci numrows,d ; number of rows to print top: lda numrows,d sta numonrow,d ; inner loop limit is same as rows left top2: charo '*',i lda numonrow,d suba 1,i sta numonrow,d ; number of stars left to print on line brne top2 ; branch if more to print on this line charo '\n',i ; no more so output newline character lda numrows,d suba 1,i sta numrows,d ; number of rows to print is decreased brne top ; branch if more rows to print numonrow: block 2 ; inner loop counter numrows: block 2 prompt: ascii Enter number of rows\x00 ; number of rows still to print Comp 162 Notes Page 15 of 19 February 11, 2013

16 Nine simple high-level language programs and their translations into Pep/8 1 High level language int a,b,c; input(a,b) c=a+b; output (c); Pep/8 deci a,d deci b,d adda b,d ; a + b sta c,d deco c,d a: block 2 b: block 2 c: block 2 2 High level language int a,c; input(a); c=a+5; output(c); Pep/8 deci a,d add five,i ; a + 5 sta c,d deco c,d a: block 2 c: block 2 five:equate 5 3 High level language Pep/8 int a,b,c; input (a,b); c=(a+b)/2; output (c); deci b,d adda b,d asra sta c,d deco c,d a: block 2 b: block 2 c: block 2 ; (a+b)/2 Comp 162 Notes Page 16 of 19 February 11, 2013

17 4 High level language int a; input(a); output (3*a+27); Pep/8 deci a,d asla ; 2a adda a,d ; 3a adda constant,i ; 3a+27 sta a,d ; used for result deco a,d a: block 2 constant:equate 27 5 High level language Pep/8 int a,b; input(a,b); output("the sum is "); output(a+b); deci a,d deci b,d adda b,d sta a,d ; a now a+b stro label,d deco a,d a: block 2 b: block 2 label:ascii "The sum is \x00" 6 High level language int a,b; input (a,b); output(a); output(" + " ); output(b); output(" = " ); output(a+b); Pep/8 deci a,d deci b,d adda b,d sta temp,d deco a,d stro plus,d deco b,d stro equals,d deco temp,d a: block 2 b: block 2 temp: block 2 plus: ascii " + \x00" equals:ascii " = \x00" ; for a+b Comp 162 Notes Page 17 of 19 February 11, 2013

18 7 High level language int a; input(a); a = a + a%4; output(a); Pep/8 deci a,d anda 3,i ; a%4 adda a,d ; a+a%4 sta a,d deco a,d a: block 2 8 High level language int score, exam1, exam2; const int bonus = 10; int main() { output ( Enter exam scores: ) input (exam1); input (exam2); score = (exam1+exam2)/2 + bonus; output( Your semester score is: ); output(score); } Pep/8 br main score: block 2 exam1: block 2 exam2: block 2 bonus: equate 10 main: stro prompt,d deci exam1,d deci exam2,d lda exam1,d adda exam2,d asra adda bonus,i sta score,d stro label,d deco score,d prompt:ascii Enter exam scores: \x00 label:ascii Your semester score is: \x00 Comp 162 Notes Page 18 of 19 February 11, 2013

19 9 High level language Pep/8 int A, B, C, result; int main() { output( Enter three integers: ); ; } input(a); input(b); input(c); result = (A/4) + (B%32) + (C*3) 24 output( Result is: ); output(result); stro prompt,d deci a,d deci b,d deci c,d asra asra sta result,d ; a/4 lda b,d anda 31,i adda result,d sta result,d ; a/4 + b%32 lda c,d asla adda c,d adda result,d suba 24,i sta result,d ; a/4 + b%32 + 3*c - 24 stro label,d deco result,d a: block 2 b: block 2 c: block 2 result:block 2 prompt:ascii Enter three integers:\x00 label: ascii Result is: \x00 Reading Chapter 5 This covers the basic properties of the Pep/8 assembly language and has examples of programs with no branching or loops Next we will look at the part of Chapter 6 that shows how we can implement if and while statements Comp 162 Notes Page 19 of 19 February 11, 2013