1. Assembly Programming & Machine Code

Transcription

1 FIU - DEPARTMENT OF ELECTRICAL AND COMPUTER ENGINEERING 1. Assembly Programming & Machine Code EEL 4746L - Microcomputers - I Lab

2 Aim: Understanding the basics of assembly programming and machine code by writing a program to display a string in both assembly language and machine code. Background: All the digital computing devices or the micro-computers viz., the micro-controllers (µc) and the micro-processors (µp) understand and perform operations based on the binary codes defined internally by their manufacturers. These codes which the device can understand and work accordingly are referred to as instruction codes. Processor chips are often categorized by the quantity and type of instruction codes they support. Though the instruction codes might differ from one device to the other, the instruction code handling remains the same. For such a device to perform any job, the instructions are given in binary format known as opcodes which constructs the machine language. These opcodes are stored in memory locations (can be either internal or external RAM or ROM). The instruction pointer (IP) is the register that points to the memory location of the next instruction. The 8086 has 8 general-purpose registers, each of which is 16 bits wide. AX (Accumulator): Most arithmetic and logical computations use this register BX (Base Reg): Normally used to store base addresses (later) CX (Count Reg): Used for counting purposes, like number of iterations while looping, number of characters in a string, etc. DX (Data Reg): a true general purpose register. SI (Source Index): Used as a pointer to access memory indirectly DI (Dest. Index): Like the SI register, this is also used for indirectly accessing the memory BP (Base Pointer): Like the BX register, this is also used to store base addresses. Generally, this register is used to access local variables in a procedure. SP (Stack Pointer): A very important register. Maintains the program stack, and so should be used carefully. Each of these 16-bit registers can be divided into two 8-bit wide register blocks that can be used individually. 2. Segment Registers The 8086 has 4 special segment 16-bit registers that deal with selecting blocks (segments) of the memory. The CS (Code Segment) registers points at the segment containing the currently executing machine instructions. Since you can change the value of the DS register, you can switch to a new code segment when you want to execute the code located there. The DS (Data Segment) register generally points at global variables for the program. You can change the value of the DS register to access additional data in other segments. 2

3 The ES (Extra Segment) register is an extra segment register programs often use this segment register to gain access to segments when it is difficult or impossible to modify the other segment registers. The SS (Stack Segment) register points at the segment containing the 8086 stack. The stack is where the 8086 stores important machine state information, subroutine return addresses, procedure parameters, and local variables. In general, you do not modify the stack segment register because too many things in the system depend upon it. 3. Special Purpose Registers There are two special purpose registers on the 8086, i.e. the instruction pointer (IP) and the flag register. The IP is sometimes referred to as the PC (program counter). These registers cannot be accessed directly; rather, they are modified by the CPU during execution. The IP contains the address of the instruction being executed currently. This address is the offset within the code segment, specified by the CS register. The flag register is a collection of 1-bit values that hold information regarding the state of the system. Though it is a 16-bit register, only 9 of those bits are used. For most practical purposes, only 4 flags are used: zero, carry, sign and overflow. Segmentation The 8086 is a 16-bit processor, with 16-bit registers and hence the address space which can be accessed is 2 16 bits (i.e. 64 kilobytes). But with the clever use of segmentation, the address space can be expanded to 1 Megabyte. Though 1 Megabyte seems very small in today's context, in those days, it was a lot of memory (especially since the cost of making physical memory was exorbitant). Before we start with segmentation, let us look at the way in which the address computation is done in the 8086: To provide flexible addressing capabilities, a data address may be formed by adding together a combination of BX or BP contents, SI or DI contents and a displacement. (This we will see in detail, when we cover addressing modes). The result of such a computation is called the offset or the effective address (EA). The final address is determined by the EA and the appropriate data segment (DS), extra segment (ES) or stack segment (SS) register. Segmentation provides a powerful mechanism to manage memory. Programmers tend to partition their program into logically independent modules. With segmentation, this logical partitioning can be extended to keep these modules in physically independent sections (called segments). Segmentation also allows two programs to share memory. The effective address is a 16-bit value. However, to address 1 MB, there are 20 bits in the physical address. Where do these extra 4 bits come from? They are obtained from the segment register (to which the EA is added). The addition is carried out by appending four 0 bits to the value of the segment register, before adding, thereby producing a 20-bit result. This is shown in the figure below. Therefore, an address on the 8086 is written as segment: offset. The size of the offset 3

4 (16-bits) limits the size of each segment to 64K. The number of segments is also limited to 65,536 segments per program, but this is not a practical limitation, since there are typically only a dozen segments in a program. The use of segmentation typically divides the memory into overlapping segments, with each segment being 64K bytes long and beginning at a 16-byte boundary. Summarizing segmentation, the advantages are: Allows memory capacity to be 1 MB, though the address associated with each instruction is only 16 bits long. Allows the instruction, data or stack segment of a program to be more that 64K, by using multiple code segments (or data/stack segments). Facilitate the use of separate memory areas for a program, its data, its stack, etc. One of the reasons why segmentation is not a very popular concept among programmers is that it is very difficult to access more than 256K of memory at once. This limitation is because there are only segment registers. Accessing more than 256K requires quite a bit of bookkeeping. The general structure of an instruction in assembly programming is: Label Operator Operand[s] ;Comment Label - optional alphanumeric string 1st character must be a-z, A-Z,?,@,_,$ Last character must be : Operator - assembler language instruction mnemonic an instruction format for humans assembler translates mnemonic into hexadecimal opcode example mov is f8h Operand[s] - 0 to 3 pieces of data required by instruction can be several different forms delineated by commas immediate, register name, memory data, memory address Comment - Extremely useful in assembler language 4

5 Compiler: To execute any assembly program, the program first has to be converted to binary format using opcodes understandable by the µc/µp. For this, we use the open-source software NASM available for free download from rc6-dos.zip. We will write, compile and execute our programs from the MS-DOS command prompt. Steps to set-up the folder on H-drive: 1. Log-on to any computer connected to FIU Novell network (e.g., in EIC labs and the micros lab). 5

6 2. Open the H drive in windows explorer and create a folder called Micros (or any other name). 3. From the downloaded ZIP file, copy the nasm.exe file to the folder created in step We will now work in this folder to work on our programs. Steps to write a program: You can write your program using any text editing software available for Windows OS or DOS that you feel comfortable with e.g., the edit program, notepad or wordpad or notepad++. But, the compilation and execution have to be performed in the command prompt. The following are the steps you can follow to write your program in the command prompt itself. 1. On Windows XP, click on START button on bottom left corner of the screen and click RUN. There, type cmd and click open. On Windows Vista, click on START and type cmd in the search box. In the results box, you will see the program with a black icon. Click on it to open it. 2. Type H: or the drive letter that you are using and press ENTER 3. Then type cd <foldername> and press ENTER to change into that folder 4. To create/edit a file, type edit <filename>.asm and press ENTER. You will now see a blue screen where you can type your program. When done, click FILE SAVE and FILE EXIT in sequence or FILE EXIT and it will ask you if the changes have to be saved. Do accordingly and you will get back to the DOS prompt. Steps to compile a program: The compiler that we will be using is the NASM compiler that stands for Netwide ASseMbler. To compile the assembly program to a DOS executable binary file, use the following syntax: nasm -f bin <filename>.asm -o <filename>.com You will then see a new executable file created in the folder using windows explorer. To execute it, simply type its name in the DOS prompt and press ENTER. 6

7 Home Work: (Preparation before the lab) The instruction set for Intel 8086 processor is included in the IC datasheet from page 26 to 30 and you are expected to go though the instructions and understand what registers they affect. Please note that you are NOT expected to know all. Review some basic MS-DOS commands like dir, mkdir, cd, delete, copy con, copy and move to get familiarized with the DOS environment. Program: org 0100h mov dx, msg mov ah, 09h int 21h mov ah, 4ch int 21h msg db Micros Lab, $ Generate the program table: 1. Knowing the mnemonic: A mnemonic is the instruction with its operands; for example, consider the mnemonic mov dx, msg. Here, the instruction is mov and the operands are dx and msg. The first operand is a 16-bit (2 byte) general purpose register and the second operand is the first memory location (also 16-bit) of the data. Similarly, for the mnemonic mov ah, 4ch the instruction is again mov the first operand is now the higher 8-bits of the accumulator and the second operand is an 8-bit hexadecimal data. 2. Generating the opcode: Once the mnemonic, its instruction and operands are understood, we are ready to find its binary code that the processor can understand. This binary format of the mnemonic that the processor understands is called the opcode for the mnemonic. For this, we refer to the chip designer s specifications given in the chip datasheet. Since we are programming for Intel 8086 µp, we refer to the chip s datasheet. Let us find the opcodes for the following two mnemonics: (a) mov dx, 0240h: (i) This mnemonic is a move instruction where the second operand (source) is a 16-bit data (a memory location, for example) and the first operand (the destination) is a 16- bit general-purpose register. From the table 2 of the datasheet (page numbers 26-30), we look for the instruction mov. We can see that the opcode changes for different combination of source and destination. In our case, it is 16-bit immediate (data) to 16-bit register (other than accumulator). Hence, the opcode format, according to the table will be where each of the blocks is of 8-bits. 7

8 1011 w reg data data if w=1 From the notes given at the end of the table, we understand that the first four bits 1011 define the kind of mnemonic for the µp to understand and expect what is coming up next. w=0 defines 8-bit information and w=1 defines 16-bit information. In our case, it should be 1 because we are dealing with 16-bit operands reg data data if w=1 (ii) Similarly, reg has to be replaced by binary equivalent for the destination register and from the tables, DX= data data if w=1 (iii) We now insert the 16-bit data in each of the successive 2 bytes (lower byte) (upper byte) This is the opcode for the above mnemonic. For simplicity, we represent it using hexadecimal system. B A (iv) Now, the amount of memory space required to complete the instruction is 3-bytes. This is called the length of the mnemonic. Hence, if the instruction starts at a memory location 0100H, the next instruction will start at 0100H + 3bytes = 0103H. When the opcode is fetched, the value of the IP register will be 0103H where the next instruction begins. (b) mov bl, byte [msg+1] i. This instruction reads the contents of memory location 1 byte after the location pointed by msg. the instruction is mov, the first operand is lower byte of a general purpose register and the data read from memory is a byte. Here, the second operand is an indirect addressing mode wherein we are giving 1byte of immediate data from a memory location and storing it in a general purpose register. The opcode format is: disp (lower byte disp (upper byte d w mod reg r/m ii. Again from the tables, we observe that if transfer is TO a register, d=1; if the transfer is FROM a register, d=0. In the present case, d=1. Since the data that will be transferred is from a memory location and since the data is 8-bit long, w=0. disp (lower byte disp (upper byte mod reg r/m iii. The mod field (2 bits) gives the length of the displacement field: 00 means no displacement, 01 means one byte, and 10 means two bytes. Now, the register we are using is the 8-bit wide BL with reg=011. The value for r/m is chosen such that the processor will look for the memory location in the next two bytes and take it as the effective address without any offset. Hence, we choose r/m=110; read the footnote in the manual disp (lower byte disp (upper byte 8

9 iv. Now, we give the displacement bytes. To give the displacement bytes, we need to know where our data will be stored. If the base address of data segment is provided, that will be the first address of the first byte referred by msg. If undeclared, assume the data segment at the end of the program instructions v. Finish writing the opcodes for the mnemonics and consider keep track of memory locations. The present mnemonic takes up 4-bytes of memory to complete the instruction in the table. When the complete opcodes and memory locations are figured out, we can start allocating the memory for data and complete the unfilled memory locations in the opcode. Assuming that our data segment starts at location 12DH, the completed opcode is: 8 A 1 E 2 D 0 1 Update the table with the new opcode. Report: 1. Background about the program with a flowchart 2. Prepare a table in the following format and enter the data for each instruction Memory Address Mnemonic Opcode Description The memory address is the starting location of the instruction. Mnemonic is the assembly language instruction. Opcode is the opcode of the instruction that you create using the instruction set. Description should tell a reader the importance/job of the instruction. 3. The program; both the one included in this file and the modified one that we used to put the second part of the name on the next line. Include the outputs by using the screen capture method. 4. Include your conclusions from the two experiments. Reference: 1. Professional Assembly Language by Blum, Richard (available online on FIU NetLibrary) 9