Assembly Language. Operand Size. The internal registers. Computers operate on chunks of data composed of a particular number of bits.

Size: px

Start display at page:

Download "Assembly Language. Operand Size. The internal registers. Computers operate on chunks of data composed of a particular number of bits."

Melina Rich
6 years ago
Views:

1 1 2 Chapter 6 Assembly Language Operand Size 8 bits 16 bits Computers operate on chunks of data composed of a particular number of bits. The 68K has a 32-bit architecture and a 16-bit organization. Internal registers hold 32 bits Can perform operations on 32-bits Has a 16 bit external data bus - operands must be moved in and out of memory as two 16 bit words Some internal data paths are 16 bit. 68K can handle 16 bit and 8 bit values Byte-wide memory A 100C 100E Word -wide memory The 68K has a byte-addressable architecture Successive bytes are stored at consecutively numbered byte addresses Any byte can be individually written to or read from. 16-bit words are composed of 2 bytes and are stored at consecutive even addresses: 0,2,4, bit longwords are stored at addresses 0, 4, 8, C C 32 bits Longword-wide memory 3 4 When we store a 32 bit longword, where do the bytes go? Consider the example of storing $ into memory location $. The 68K would store it as : Where the most significant byte is at the lowest address. This order is called Big -Endian. If the bytes are stored in the opposite order, with the most significant byte at the highest address like: Where the least significant byteis at the lowest address, we call the order Little-Endian. When we encounter a command like MOVE.W DO,1234 The following bit copy is performed: In th 68K all addresses are 32 bit values This should allow for an address space of 2 32 bytes = 4 G of memory. Here 2 10 = K 2 20 =1,048,576 1M, 2 30 = 1,073,741,824 1 G However, the original design was for a 64 pin package which limited it somewhat. The address bits A 24-A 31 are not connected to pins and cannot access memory. This effectively forces the address bus to 24 bits and the original 68K can only access 2 24 = or 16 M of memory. The internal registers The 68K has a register-to -memory architecture. This means typical instructions will specify one operand in memory and the others as a register like: ADD $1234,D d 08 -d 15 d 00 -d 07 which causes the contents of location $1234 to be added to D The 68K consists of 8 32-bit data registers, 8 32-bit address registers, an 8 bit condition code register, an 8 bit status byte (used by operating system to define the operating mode of the 68K) and a 32-bit program counter.

2 5 6 The programmer's view of the 68K: d 16 d 15 d 00 d 31 d 08 d 07 D0 D1 D2 D3 D4 D5 D6 D7 a 31 a 16 a 15 a 00 A0 A1 A2 X N Z V C A3 A4 A5 A6 A7 PC CCR All of the data registers are general-purpose, commands which can be applied to D0 can be applied to any data register. We know one advantage of multiple data registers is to store frequently used data on chip for quicker access. The number of internal data registers is a function of economics. Most instructions store the op -code and operand register in a 16-bit word. It requires 3 bits to describe the 8 data registers. More registers would require more bits, leaving fewer bits dedicated to opcode and hence fewer instructions capable of being described in this length word. Memory requires a 32 bit specification. Instructions that access memory are longer than instructions that access registers. Most high level languages do not allow for the programmer to specify the use of registers for variable allocation this is the compilers job. ************************************************************ C is one of the exceptions: In C there is a storage class specifier called register. It can be applied to local variables and formal parameters in functions. The class specifier is intended to be used where many references will be made to the same variable. The register specifier originally applied only to variables of type int or char (and indeed the C standard permits the compiler to ignore the specifier the current standards state "access to the object be as fast as possible") 7 8 Some C code: int int_power(register int m, register int e) { register int temp; temp=1; for ( ; e ; e--) temp=temp*m; return temp; } Recall we specify operations as either byte, word or longword operations by appending the.b,.w or.l to the mnemonic. Each affects a certain sequence of bits of the operand:.b D 00 D 07.W D 00 - D 15 The remaining bits would remain unchanged. CLR.W D1 Would force the low 16 bits of D1 to 0's The number of actual register variables permitted depends on the environment and implementation of C. For the sake of portability if no registers are available the compiler w ill automatically transform register variables to non register variables, if needed. ********************************************************** When referring to the bits of a data register (for purposes of RTL) we will denote consecutive bits i to j in register Dn by Dn(i:j). If we wanted to refer to bits 16 through 31 of register D5 we would write D5(16,31) D1 XXXXXXXXXXXXXXXX Where X stands for whatever was already there. If [D1] = $ then after CLR.W D1 we have [D1] =$ Assembly form RTL form ADD.L D0,D1 [D1(0:31)] [D1(0:31)]+[D0(0:31)] ADD.W D0,D1 [D1(0:15)] [D1(0:15)]+[D0(0:15)] ADD.B D0,D1 [D1(0:7)] [D1(0:7)]+[D0(0:7)] We can omit the slice notation unless we are meaning to emphasize what bits we are working on.

3 9 10 The affect on the carry bit of the.b,.w or.l is determined only by the corresponding bits for that size operation. Consider the following example: [D0] = $ , [D1] = $ABCDEF98 In hexadecimal 68K Address Registers The 68K's eight 32-bit address registers A0 A7 act as pointer registers, since they hold the address of some memory location. This will be important wen dealing with arrays, matrices, tables and vectors ABCDEF98 BE EF A0 A6 are identical in the way they are treated. A7 has the additional responsibility of being a stack pointer for storing subroutine addresses. Assemble code Register D1 CCR carry bit C ADD.B D0,D1 [D1]=ABCDEF10 [C] = 1 ADD.W D0,D1 [D1]=ABCD4610 [C] = 1 ADD.L D0,D1 [D1]=BE [C] = 0 It is easy to make an error if we do not pay attention to using consistent size operations on data registers. Consider the following: MOVE.B XYZ,D0 Copy contents of location XYZ to D0 SUB.B #5,D0 Subtract 5 from D0 CMP.W #12,D0 IS D0 > 12 BGT Test Branch on Greater than Notice on the MOVE.B we are only changing bytes d 00 d 07. The same is true when we subtract 5 from D0. When we get to the third step, however we are comparing d 00 d 15 to the word representation of 12. The problem is we don't have any idea what is in d 08 d 15. We may or may not wind up with the desired result. Many of the operations we did with data registers can be done with address registers with a few differences: Operations on address registers do not normally affect the CCR's bits All operations on the address registers are longword operations (Ai's are treated as single entities. Any.W operation is automatically extended to a.l operation.b operations are not permitted The contents of an address are treated as a signed 2's complement value. Performing a.w operation causes the sign bit to be extended from A 15 to A 16 A 31. MOVE.W #$8022,A1 ( = ) has the effect [A1] $FFFF MOVE.W #$6121,A2 ( = ) has the effect [A2] $ Why do we allow for negative addresses? We can interpret a negative address as a move backwards. Example: Suppose A1 contains 1280 and A2 contains -40. Adding A1 and A2 results in a composite address 1240, 40 units in address lower than A1. The 68K has special mnemonics for operations that modify addresses. Some examples (destination operand is address register) ADDA.L D1,A3 ADDA = add to address register MOVEA.L D1,A2 MOVEA = move to address register SUBA.W D1,A3 SUBA=subtract from address register Using an address register to access a data element: A0 Contains address of the start of data structure A1 Will contain address of start of ith element D0 i MULU #12,D0 MOVEA.L A0,A1 ADDA.L D0,A1 12-byte data block item 0 12-byte data block item i 12-byte data block item 49 Calculate offset Copy base address to A1 Add offset to A1 Example: Address register A0 points to the beginning of a data structure in memory. The structure is made up of 50 items numbered 0 through 49. Each of the 50 items i s 12 bytes long. D0 contains the number of the item w wish to access. We wish to put the address of the item in A1. We will use the operation MULU #n,di which multiplies the 16-bit low order word in Di by n and puts a 32-bit product in Di As you can see the instruction set is rather primitive compared to high level languages. Any type of complex operation will be implemented by a sequence of primitive instructions.

4 13 14 An Introduction to the 68K instruction set Data Movement The largest set of instructions in most programs are for data movement. When we omit the.w,.l or.b qualifier we will assume a default of.w, where it makes sense. Two-operand instructions will have the format Operation source,destination Example: MOVE D3,D4 copies the contents of D3 into D4 Some 68K movement instructions Assembly RTL MOVE Di,Dj [Dj] [Di] MOVE P,Di [Di] [M(P)] MOVE Di,P [M(P)] [Di] EXG Di,Dj [TEMP] [Di], [Di] [Dj], [Dj] [TEMP] SWAP Di [Di(0:15)] [Di(16:31)], [Di(16:31)] [Di(0:15)] LEA P,Ai [Ai] P LEA Load Effective Address In the next example we will demonstrate these instructions using our assembler: Create a text file: samp.x68 ORG $ MOVE.L #$ ,D0 MOVE.B D0,D1 MOVE.W D0,D2 MOVE.L D0,D3 EXG D0,A0 SWAP D3 MOVEA.L data,a1 LEA data,a1 STOP #$2700 DATA DC.L $ABCDDCBA END $ From the DOS prompt type (and see the respone): C:\WINDOWS\Desktop\assem\68Ksim>x68k samp -L [X68K PC-2.2 Copyright (c) University of Teesside 1989,99] No errors reported. Two Files should have been created in your directory : Samp.bin, Samp.lis First we will look at Samp.lis to see what the assembler did Samp.lis (you should be able to open this with any text editor) Source file: SAMP.X68 Assembled on: at: 07:01:50 by: X68K PC-2.2 Copyright (c) University of Teesside 1989,99 Defaults: ORG $0/FORMAT/OPT A,BRL,CEX,CL,FRL,MC,MD,NOMEX,NOPCO ORG $ C MOVE.L #$ ,D MOVE.B D0,D MOVE.W D0,D A 2600 MOVE.L D0,D C C188 EXG D0,A E 4843 SWAP D MOVEA.L DATA,A F LEA DATA,A C 4E STOP #$ ABCDDCBA DATA: DC.L $ABCDDCBA END $ Lines: 12, Errors: 0, Warnings: 0. Next we will use the simulator to run our assembled code: C:\WINDOWS\Desktop\assem\68Ksim>e68k samp [E68K PC-2.2i Copyright (c) University of Teesside 1989,99] Address space 0 to ^ (10240 kbytes). Loading binary file "SAMP.BIN". Start address: 00, Low: 0000, High: At this point we will create a log of our interaction with the simulator at the '>' prompt type : log fun.log > log fun.log I will step through the program, and when done show y'all the Log file. (remember typing "quit" at the simulators prompt will quit the simulator, df display formatted registers and tr- trace, to exit trace mode type a '.') Logging to "FUN.LOG" started. >df PC=00 SR=2000 SS=00A00000 US= X=0 D0= D1= D2= D3= V= >MOVE.L #$ ,D0 >tr PC= SR=2000 SS=00A00000 US= X=0 D0= D1= D2= D3= V= >MOVE.B D0,D1 PC= SR=2000 SS=00A00000 US= X=0 D0= D1= D2= D3= V= >MOVE.W D0,D2 PC=00100A SR=2000 SS=00A00000 US= X=0 D0= D1= D2= D3= V= >MOVE.L D0,D3 PC=00100C SR=2000 SS=00A00000 US= X=0 D0= D1= D2= D3= V= >EXG D0,A0 PC=00100E SR=2000 SS=00A00000 US= X=0 A0= A1= A2= A3= N=0 D0= D1= D2= D3= V= >SWAP D3

5 17 18 PC= SR=2000 SS=00A00000 US= X=0 A0= A1= A2= A3= N= >MOVEA.L $1020,A1 PC= SR=2000 SS=00A00000 US= X=0 A0= A1=ABCDDCBA A2= A3= N= >LEA.L $1020,A1 PC=00101C SR=2000 SS=00A00000 US= X=0 A0= A1= A2= A3= N= >STOP #$2700 Processor halted at: PC= SR=2700 SS=00A00000 US= X=0 A0= A1= A2= A3= N= >DC.W $ABCD Returning to command-mode after "OPCODE 1010 EMULATION" exception. Arithmetic and Logical operations Asembly Form RTL ADD Di,Dj [Dj] [Di] + [Dj] ADDX Di,Dj [Dj] [Di] + [Dj] + [X] SUB Di,Dj [Dj] [Di] - [Dj] SUBX Di,Dj [Dj] [Di] + [Dj] - [X] MULU Di,Dj [Dj(0:31)] [Di(0:15)] [Dj(0:15)] DIVU Di,Dj [Dj(0:15)] [Dj(0:31)]/ [Di(0:15)] integer part [Dj(16:31)] remainder NEG Di [Di] 0 [Di] NEGX Di [Di] 0 - [Di] [X] AND Di,Dj [Dj] [Di] [Dj] OR Di,Dj [Dj] [Di]+[Dj] EOR Di,Dj [Dj] [Di] [Dj] NOT Dj [ Dj] [ Dj] >quit Here [X] is the contents of the X bit of the CCR (usually a copy of the carry bit) The multiplication and division are specific with regards to what they operate on. The other operations can be designated.b,.l or.w MULU Di,Dj [Dj(0:31)] [Di(0:15)] [Dj(0:15)] Multiplies two 16 bit operands and stores as 32 bit result Suppose D0 = $1234 and D1=$0202 Then MULU D0,D1 leaves $00248C68 in D1 DIVU Di,Dj [Dj(0:15)] [Dj(0:31)]/ [Di(0:15)] integer part [Dj(16:31)] remainder Divides a 32 bit operand by a 16 bit operand and stores as a 32 bit result with the low 16 bits being the quotient and the high 16 bits the remainder. Suppose D1 = $ = and D0=$4 Then DIVU D0,D1 leaves $ C in D1 (8497/4 = 2124 R 1, and =84C 16) Another point: Computers execute instructions even if the instructions don't make sense. Higher level languages are often strongly typed and would prevent the programmer from doing such things. Consider the following assembly language program that adds the ASCII representation for character 'A' to that of character 'B' The code: ORG $ MOVE.B Char1,D0 MOVE.B Char2,D1 ADD.B D0,D1 STOP #$2700 Char1 DC.B 'A' Char2 DC.B 'B' END $ The.lis file after assembled: Source file: SAMP.X68 Assembled on: at: 09:54:45 by: X68K PC-2.2 Copyright (c) University of Teesside 1989,99 Defaults: ORG $0/FORMAT/OPT A,BRL,CEX,CL,FRL,MC,MD,NOMEX,NOPCO ORG $ MOVE.B CHAR1,D MOVE.B CHAR2,D C D200 ADD.B D0,D E 4E STOP #$ CHAR1: DC.B 'A' CHAR2: DC.B 'B' END $ Lines: 9, Errors: 0, Warnings: 0. The Log file for a run: Logging to "FUN.LOG" started. >df PC=00 SR=2000 SS=00A00000 US= X=0 D0= D1= D2= D3= V= >MOVE.B $1012,D0 >tr PC= SR=2000 SS=00A00000 US= X=0 D0= D1= D2= D3= V= >MOVE.B $1013,D1

6 21 22 PC=00100C SR=2000 SS=00A00000 US= X=0 D0= D1= D2= D3= V= >ADD.B D0,D1 PC=00100E SR=200A SS=00A00000 US= X=0 A0= A1= A2= A3= N=1 D0= D1= D2= D3= V= >STOP #$2700 Processor halted at: PC= SR=2700 SS=00A00000 US= X=0 D0= D1= D2= D3= V= >DC.W $4142 quit What is the meaning of what is in D1? 2 2 X + Y Here is a program to calculate Z = X Y For X=50, Y= Answer should be : Or = 69 R 22 The assembly code: ORG $ X DC.W 50 ;value for x Y DC.W 12 ;value for y Z DS.W 1 ;create space for result ORG $1200 MOVE.W X,D0 ;Copy X to D0 MULU D0,D0 ;square X MOVE.W Y,D1 ;Copy Y to D1 MULU D1,D1 ;square Y ADD.L D0,D1 ; X^2 +Y^2 into D1 MOVE.W X,D0 ;Copy X to D0 SUB.W Y,D0 ; X-Y in D0 DIVU D0,D1 ;put(x^2+y^2)/(x-y)into D0 MOVE.W D1,Z ;Put result out to memory Z STOP #$2700 END $1200 ;End with address entry point The assembled code : Source file: SAMP.X68 Assembled on: at: 14:16:33 by: X68K PC-2.2 Copyright (c) University of Teesside 1989,99 Defaults: ORG $0/FORMAT/OPT A,BRL,CEX,CL,FRL,MC,MD,NOMEX,NOPCO ORG $ X: DC.W C Y: DC.W Z: DS.W ORG $ MOVE.W X,D C0C0 MULU D0,D MOVE.W Y,D A C2C1 MULU D1,D C D280 ADD.L D0,D E 3038 MOVE.W X,D SUB.W Y,D C0 DIVU D0,D C11004 MOVE.W D1,Z C 4E STOP #$ END $1200 Lines: 16, Errors: 0, Warnings: The log file (with comment) Logging to "FUN.LOG" started. >df PC= SR=2000 SS=00A00000 US= X=0 D0= D1= D2= D3= V= >MOVE.W $,D0 >tr PC= SR=2000 SS=00A00000 US= X=0 D0= D1= D2= D3= V= >MULU.W D0,D = PC= SR=2000 SS=00A00000 US= X=0 D0=000009C4 D1= D2= D3= V= >MOVE.W $1002,D = =9C4 16 PC=00120A SR=2000 SS=00A00000 US= X=0 D0=000009C4 D1= C D2= D3= V= >MULU.W D1,D =C 16 PC=00120C SR=2000 SS=00A00000 US= X=0 D0=000009C4 D1= D2= D3= V= >ADD.L D0,D = =90 16 PC=00120E SR=2000 SS=00A00000 US= X=0 D0=000009C4 D1=00000A54 D2= D3= V= >MOVE.W $,D = =A54 16 PC= SR=2000 SS=00A00000 US= X=0 D0= D1=00000A54 D2= D3= V= >SUB.W $1002,D0 Copied into D0 PC= SR=2000 SS=00A00000 US= X=0 D0= D1=00000A54 D2= D3= V= >DIVU.W D0,D1 Subtracted from and put in D0, D0=38 10 = PC= SR=2000 SS=00A00000 US= X=0 D0= D1= D2= D3= V= >MOVE.W D1,$1004 A54 16 = / = R = R 16 16

7 25 PC=00121C SR=2000 SS=00A00000 US= X=0 D0= D1= D2= D3= V= >STOP #$2700 Processor halted at: PC= SR=2700 SS=00A00000 US= X=0 D0= D1= D2= D3= V= >ORI.B #$00,D0 MD - Memory Display command MD C q >quit

Multiplies the word length <ea> times the least significant word in Dn. The result is a long word.

Multiplies the word length <ea> times the least significant word in Dn. The result is a long word. MATHEMATICAL INSTRUCTIONS Multiply unsigned MULU ,dn Action Notes: Example: Multiplies the word length times the least significant word in Dn. The result is a long word. 1. The lowest word of