Wednesday, February 7, 2018

Transcription

1 Wednesday, February 7, 2018 Topics for today The Pep/9 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/9 Math operations in Pep/9 Chapter 4 The Pep/9 memory Figure 441 is a good overview of the various regions of the Pep/9 memory Shaded areas are read-only write-protected sections used by the operating system Here is a summary of the memory Application Program Area Address Range 0FB8E 16 (064398) Contents This area is the user program and the run-time 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 FB8FFC16 16 ( ) FC17FFFF 16 ( ) RAM - Here is the variable part of the operating system: The system stack, globals and I/O devices ROM - Here is the unchanging part of the operating system: the loader (about 64 bytes) the trap handler (about 863 bytes) pointers to (a) base of user stack, (b) base of system stack, (c) input device, (d) output device, (e) start of loader, (f) start of trap handler Comp 162 Notes Page 1 of 17 February 7, 2018

2 Four Example programs We look at four example hexadecimal programs from the book to get an idea of how the Pep/9 machine operates Once we get to Chapter 5, we will switch to assembly code programming Example 1: Fig 433 This is a very simple program that outputs Hi A character is output by being stored at memory[fc16] This program first loads character H from Memory[000D] into register A then copies it to memory[fc16] This two instruction sequence is repeated to output i The first byte of the first instruction is D1 (binary ) This is decoded as Opcode mode The opcode is Load byte from memory In general, the 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 is responsible for figuring out operand values (this will change when we get to Chapter 5) This program outputs Hi with the ASCII codes for H (48) and i (69) in the two bytes following the STOP instruction Example 2: Figure 435 Characters are input by being read from Memory[FC15] In this program two characters are read from the input and output in reverse order The program uses memory[0013] (the first free location after the end of program) to store the first character until it is needed for output The second character is read from input and written to output without needing to be stored in memory Example 3: Figure 436 This program adds two constants, 3 and 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 17 February 7, 2018

3 Example 4: Figure 437: a self-modifying program Address Contents Remarks 0000 D1 get byte from Mem[0019] This is F1 store it at Mem[0009] overwriting the C1 get 16-bit number (5) from memory[0013] add to it the 16-bit number in memory[0015] 000A 00 (note that add is changed to sub by the 000B 15 actions of the first two instructions) 000C 91 OR with Mem[0017] = 0030 to convert to ASCII 000D E F F1 Send character to output 0010 FC Stop The first two instructions of the program get a byte (71) from location 19 (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 61) to a Sub (opcode byte 71) 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 Comp 162 Notes Page 3 of 17 February 7, 2018

4 The loader One of the built-in utilities in the Pep/9 system is a facility to load a program (written in hex) into memory Every system has a similar utility in some form The loader is a very simple program it is listed in Fig 83 if you are interested and is particular about the format of the input: (1) hexadecimal pairs separated by exactly one space or newline (2) program is terminated with zz We can write programs in hexadecimal and have the Pep/9 system run them The three steps involved are: (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/9 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 late 1940s) 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 that allow us to write in almost high-level language form 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 being one of three types: Comp 162 Notes Page 4 of 17 February 7, 2018

5 * 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 Source Program Assembler Object Program In some Pep/9 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: LDWA 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/9 assembly language: LDWA 0,i STRO Mesg4,d LDBA '\n',i CPWA 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 Comp 162 Notes Page 5 of 17 February 7, 2018

6 In addition to the binary Instruction Specifier that we saw in Chapter 4, the table shows for each instruction: * the Mnemonic (symbolic opcode) that the assembler recognizes * the Addressing modes legal with the instruction (or U indicating that the instruction does not take an operand and hence does not required an addressing mode) * the Status bits (if any) that might be changed by the action of the instruction If you compare Fig 52 with Fig 46 you will see there are a few subtle changes The 6 instructions listed as unimplemented opcode in chapter 4 now appear either as high-level input/output (deco, deci, stro, hexo) or as no-operation trap instructions (nop, nopn) (2) Comments In Pep/9, any text between semi-colon and end of line is commentary, thus ; this line is just comment ; the following instruction has commentary ldwa 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 nine Pep/9 pseudo operations on Page 238 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 Every Pep/9 program has at its last line end It marks the physical end of the source program the assembler does not read beyond this line Comp 162 Notes Page 6 of 17 February 7, 2018

7 Here are some approximate equivalencies between declarations in a high-level declarations and pseudo operations in Pep/9 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 LDBA 0x000D,d STBA 0xFC16,d LDBA 0x000E,d STBA 0xFC16,d STOP ASCII "Hi" END ; get H ; output it ; get i ; output it 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 Comp 162 Notes Page 7 of 17 February 7, 2018

8 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 ldwa N,d ; load it into Register A adda five,d ; add the contents of a location containing 5 stwa 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 end We can choose to store all constants that the program needs in their own memory locations like this But it is shorter, faster and a little more natural if we are able to use the number 5 as part of an instruction as in the following: deci N,d ldwa N,d adda 5,i ; add 5 to register immediate mode stwa N,d deco N,d N: block 2 end The ",i" in the adda instruction indicates immediate mode It indicates that 5 is the operand itself Contrast this with ldwa 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 ldwa limit,d cpwx limit,d suba limit,d limit: word 19 Comp 162 Notes Page 8 of 17 February 7, 2018

9 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) is similar but uses immediate mode and runs faster ; Program B ldwa 19,i cpwx 19,i suba 19,i But program B has two disadvantages: (1) if we need to change the limit from 19 to some other number 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 ldwa cpwx suba limit,i limit,i limit,i The equate assembler directive lets us associate a symbolic name with a value After assembly, programs B and C are identical Comp 162 Notes Page 9 of 17 February 7, 2018

10 Location of variable declarations in a Pep/9 program 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 end (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 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 ldwa a,d adda b,d stwa c,d deco c,d a: word 30 b: word 25 c: block 2 end a: word 30 b: word 25 c: block 2 ldwa a,d adda b,d stwa c,d deco c,d end br main a: word 30 b: word 25 c: block 2 main: ldwa a,d adda b,d stwa c,d deco c,d end ldwa a,d adda b,d stwa c,d deco c,d end a: word 30 b: word 25 c: block 2 Comp 162 Notes Page 10 of 17 February 7, 2018

11 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 end so does not see the definitions of symbols a, b and c Trap Instructions Instructions DECO, DECI, HEXI, STRO, NOP and NOPn are the six instructions that 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 - 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 - the data saved is restored - control is returned to the user program using the RETTR (return from trap) instruction Thus these six instructions are slow compared with non-trap instructions but you probably won t notice the difference Here is what appropriate action" means for some of these trapped instructions: DECI: inputs input characters Checks they form a legal integer Outputs an Error message if invalid characters are input DECO: outputs an appropriate sequence of decimal digits maybe preceded by a sign character HEXO: outputs 4 hexadecimal digits STRO: outputs the characters in a null-terminated string Recall that we can set up a string in memory using the ascii directive How does STRO know the length of the string Pep/9 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 Comp 162 Notes Page 11 of 17 February 7, 2018

12 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 four instructions above, NOP and NOPn are also trapped These are no operation instructions; sometimes it is useful to have an instruction that doesn t do anything! Symbols in Pep/9 Identifiers: follow usual identifier rules (start with a letter, continue with letters, underscore or digits) but in Pep/9 they can be no more than 8 chars long Many assembly languages have similar length restrictions Pep/9 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) 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 end When run, this program outputs I 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 I is 49 (hex) Comp 162 Notes Page 12 of 17 February 7, 2018

13 Consider also the following self-modifying program similar to one we saw earlier ldba 0x70,i stba X,d ldwa 5,i X: adda 3,i stwa N,d deco N,d N: block 2 end When it runs, the program modifies the byte at X This is the opcode byte of the 4th instruction It changes it from 60 (ADD) to 70 (SUB) so the program outputs 2 not 8 Math operations in Pep/9 Multiplication If we are multiplying by a power of 2 then we just need a sequence of left shifts Thus, to compute N * 8 ldwa N,d asla asla asla 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? ] ldwa 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 Division We can easily compute X/Y (truncated) if Y is a power of 2 using right shifts For example, to compute P/16 ldwa P,d asra ; P/2 asra ; P/4 asra ; P/8 asra ; P/16 If Y is not a power of 2, the required program is more complex Comp 162 Notes Page 13 of 17 February 7, 2018

14 Modulus We can easily compute P%Q if P is positive and Q is a power of 2 For example, the result of T % 8 is the rightmost 3 bits of T thus ldwa T,d anda 7,i In general, computing a remainder is more difficult as the following table illustrates M N M%N M&(N-1) Simple arithmetic and assignment statement High-level language: M = N * 8 + T; Pep/9: ldwa N,d asla asla asla adda T,d stwa M,d Reading The binary/hex level is covered in chapter 4, you can skim step-by-step details of how particular instructions work Chapter 5 covers the basic properties of the Pep/9 assembly language Next we will look at more translations of high-level language into Pep/9 then at how the assembler works Comp 162 Notes Page 14 of 17 February 7, 2018

15 Review Questions 1 Why can t we use the same label for a variable and an instruction as in L: block 2 L: ldwa M,d Surely the assembler will know that brgt L ; refers to L on the instruction And ldwa L,d ; refers to L on the variable 2 How can you have two labels on the same variable thus enabling a programmer to use either a short identifier (eg, C) or a long one (eg, COUNTER) for the same location? 3 Can we have two labels on the same instruction? 4 Following our example of multiplication by 29, give a sequence of instructions for calculating M times 43 (101011) 5 In Pep/9, not every combination of opcode and addressing mode is valid Using Fig 52, or otherwise, identify the 16 combinations that would be flagged as invalid either at assembly time or at run-time Comp 162 Notes Page 15 of 17 February 7, 2018

16 Review Answers 1 Because, as we have seen, everything is bits If we had M: block 2 L: brgt X It is legal, though inadvisable, to have brgt M ; branch to a data location and to load the first 2 bytes of an instruction ldwa L,d 2 For example C: block 0 COUNTER: block 2 3 Two labels could be used as in L: nop0 ; dummy instruction LOOP: ldwx M,d ; real top of loop But L and LOOP will not have the same value To get two values the same you could figure out the address of the instruction (eg XYZ) then have L: equate XYZ 4 ldwa M,d ; M 1 asra ; 2M 0 asra ; 4M adda M,d ; 5M 1 asra ; 10M 0 asra ; 20M adda M,d ; 21M 1 asra ; 42M adda M,d ; 43M 1 Comp 162 Notes Page 16 of 17 February 7, 2018

17 5 Opcode Mode(s) stba stbx stwa stwx deci stro nop i i i i i i, s, sx, sfx d, n, s, x, sf, sx, sfx Comp 162 Notes Page 17 of 17 February 7, 2018