1 / 50

Lecture 4

Lecture 4. Assembly Language. Contents. Program Flow Control Conditional Instructions Loops Procedures. Program Flow Control. Controlling the program flow is a very important thing, this is where your program can make decisions according to certain conditions.

kyrene
Download Presentation

Lecture 4

An Image/Link below is provided (as is) to download presentation Download Policy: Content on the Website is provided to you AS IS for your information and personal use and may not be sold / licensed / shared on other websites without getting consent from its author. Content is provided to you AS IS for your information and personal use only. Download presentation by click this link. While downloading, if for some reason you are not able to download a presentation, the publisher may have deleted the file from their server. During download, if you can't get a presentation, the file might be deleted by the publisher.

E N D

Presentation Transcript

  1. Lecture 4 Assembly Language

  2. Contents • Program Flow Control • Conditional Instructions • Loops • Procedures

  3. Program Flow Control • Controlling the program flow is a very important thing, this is where your program can make decisions according to certain conditions. • Remember the if statement in C programming language. • In the Assembly language, flow control is handled by some several Jump instructions.

  4. Unconditional Jumps • The basic instruction that transfers control to another point in the program is JMP: JMP label • To declare a label in your program, just type its name and add ":" to the end. • A label can be any character combination but it cannot start with a number. Examples: label1: label2: a:

  5. More About Labels • Label can be declared on a separate line or before any other instruction • Examples: x1: MOV AX, 1 x2: MOV AX, 2

  6. JMP Example ORG 100H MOV AX, 5; set AX to 5. MOV BX, 2; set BX to 2. JMP calc; go to 'calc'. back: JMP stop; go to 'stop'. calc: ADD AX, BX; add BX to AX. JMP back; go 'back'. stop: RET; return to operating system.

  7. JMP in Detail • There are three types of the JMP instruction: • Short Jump • Near Jump • Far Jump • Short and near jumps are intrasegment jumps and far jump is intersegment jump.

  8. Jump Types

  9. Short Jump • The jump address is not stored in the opcode. • Instead, a distance, or displacement, follows the opcode. • Therefore, short jumps are also called relative jumps. • The displacement takes a value in the range between -128 and +127.

  10. Short Jump Illustration • The displacement is added to instruction pointer (IP) to generate the jump address within the current code segment. • The instruction branches to thisnew address forthe next instructionin the program.

  11. Short Jump Example 0000 33 DB XOR BX, BX 0002 BB 0001 START: MOV AX, 1 0005 03 C3 ADD AX, BX 0007 EB 17 JMP SHORT NEXT ... 0020 8B D8 NEXT: MOV BX, AX 0022 EB DE JMP START Note: You don’t have to use SHORT directive as the compilers choose the best form of the jump instruction.

  12. Near Jump • The near jump is similar to the short jump, except that the distance is farther. • A near jump passes control to an instruction in the current code segment located within ±32K bytes from the near jump instruction. • Near jump is also a relative jump.

  13. Near Jump Example 0000 33 DB XOR BX, BX 0002 BB 0001 START: MOV AX, 1 0005 03 C3 ADD AX, BX 0007 E9 F601JMP NEXT ... 0200 8B D8 NEXT: MOV BX, AX 0202 E9 FDFDJMP START Note: The displacement is displayed as F601. Indeed, the actual displacement is 01F6 because the high byte is written into the second byte (little endian).

  14. Far Jump • A far jump instruction obtains a new segment and offset address to accomplish the jump. • The far jump instruction sometimes appears with the FAR PTR directive. • Another way to obtain a far jump is to define a label as a far label. A label is far only if it is external to the current code segment or procedure (i.e. the compiler sets it automatically).

  15. Conditional Jumps • Unlike JMP instruction that does an unconditional jump, there are instructions that do a conditional jumps (jump only when some conditions are in act) • Conditional jumps are always short jumps. • These instructions are divided in three groups: • First group just tests single flag • Second group compares numbers as signed • Third group compares numbers as unsigned. 

  16. General Syntax • The general syntax for conditional jumps: <Conditional jump instruction> <label> Example: JC label1 • If the condition under the test is true, a branch to the label occurs. • If the condition is false, the next sequential step in the program executes.

  17. Jump Instructions That Test Single Flag

  18. Jump Instructions for Signed Numbers

  19. Jump Instructions for Unsigned Numbers

  20. Signed or Unsigned? • The numbers in a comparison may be signed or unsigned, according to your selection. • When signed numbers are compared, use the instructions with the terms “greater than”, “less than”, etc. • When unsigned numbers are compared, use the instructions with the terms “above” and “below”.

  21. Conditional Jump Example ORG 100H MOV AL, 25; set AL to 25. MOV BL, 10; set BL to 10. CMP AL, BL; compare AL - BL. JE equal; jump if AL = BL (Z = 1). MOV CX, 1; if it gets here, then AL <> BL JMP stop; so set CX, and jump to stop. equal:; if gets here, MOV CX, 0; then AL = BL, so clear CX. stop: RET; gets here no matter what.

  22. Loops

  23. Loop Example: C Code • Write a program that sums the contents of two arrays and stores the result over the second array. short arr1[100]; short arr2[100]; int count = 100; intndx = 0; while (count > 0) { arr2[ndx] = arr1[ndx] + arr2[ndx]; ndx++; count--; }

  24. Loop Example: Assembly Code org 100h mov cx, 100 ; Number of elements in the blocks mov bx, 0 ; Start index L1: mov ax, BLOCK1[bx] ; read next number from BLOCK1 add ax, BLOCK2[bx] ; add next number from BLOCK2 mov BLOCK2[bx], ax ; store the result add bx, 2 ; skip to next element loop L1 Ret BLOCK1 DW 100 DUP (1) BLOCK2 DW 100 DUP (2)

  25. Another Solution org 100h movcx, 100 ; Number of elements in the blocks mov SI, offset BLOCK1 mov DI, offset BLOCK2 L1: mov ax, [SI] ; read next number from BLOCK1 add ax, [DI] ; add next number from BLOCK2 mov [DI], ax ; store the result add SI, 2 ; skip to next element add DI, 2 loop L1 Ret BLOCK1 DW 100 DUP (1) BLOCK2 DW 100 DUP (2)

  26. Yet Another Solution ORG 100h MOV CX, 100 ; Number of elements in the blocks MOV SI, offset BLOCK1 MOV DI, offset BLOCK2 L1: LODSW ; read from source into AX ADD AX, [DI] ; add next number from BLOCK2 STOSW ; store the result into dest. LOOP L1 RET BLOCK1 DW 100 DUP (1) BLOCK2 DW 100 DUP (2)

  27. Nested Loops • Loops are basically the same jumps, it is possible to code loops without using the loop instruction, by just using conditional jumps and compare, and this is just what loop does. • All loop instructions use CX register to count steps, as you know CX register has 16 bits and the maximum value it can hold is 65535 or FFFF • However with some agility it is possible to put one loop into another, and receive a nice value of 65535 * 65535 * 65535 ....till infinity.... or the end of ram or stack memory. • It is possible store original value of CX register using PUSH CX instruction and return it to original when the internal loop ends with POP CX

  28. Nested Loop Example ORG 100H MOV BX, 0; total step counter. MOV CX, 5 k1: INC BX ; any other instructions PUSH CX MOV CX, 5 k2: INC BX ; any other instructions PUSH CX MOV CX, 5 k3: ADD BX, 1 ; any other instructions LOOP k3 POP CX LOOP k2; internal loop. POP CX LOOP k1; external loop. RET

  29. Limitation • JMP can jump to anywhere in the code segments • But conditional jumps can only jump 127 bytes forward and 128 bytes backward • Note that most instructions are assembled into 3 or more bytes • This limitation can be avoided using a simple trick

  30. Example ORG 100H MOV AL, 5 MOV BL, 5 CMP AL, BL ; JE equal ; unable to jump! JNE not_equal JMP equal not_equal: ADD BL, AL SUB AL, 10 XOR AL, BL JMP skip_data db 256 dup(0); 256 bytes skip_data: ; any other instructions here JMP stop equal: ; any other instructions here stop: RET

  31. Procedures • Procedure is a part of code that can be called from your program in order to make some specific task (remember the functions in C). • Procedures make program more structural and easier to understand. • Generally procedure returns to the same point from where it was called.

  32. Procedure Syntax • name PROC      ; here goes the code      ; of the procedure ...RETname ENDP • name - is the procedure name • the same name should be in the top and the bottom, this is used to check correct closing of procedures.

  33. Procedure Example SUMS PROC ADD AX, BX ADD AX, CX ADD AX, DX RET SUMS ENDP

  34. Some Notes on the Syntax • Probably, you already know that RET instruction is used to return to operating system. • The same instruction is used to return from procedure (actually operating system sees your program as a special procedure). • PROC and ENDP are compiler directives, so they are not assembled into any real machine code. Compiler just remembers the address of procedure. 

  35. Calling a Procedure • CALL instruction is used to call a procedure. • Example:  ORG 100H CALL m1 MOV AX, 2 RET ; return to operating system. m1 PROC MOV BX, 5 RET ; return to caller. m1 ENDP END

  36. CALL and RET • CALL saves a return address on the stack. • RET removes the return address from the stack and places it into IP. • Don’t forget to put a RET at the end of a procedure! • You can use several RETs in a procedure (like return in C).

  37. Passing Parameters to a Procedure • There are several ways to pass parameters to a procedure • The easiest way is by using registers • Put parameters to the registers and call the procedure • The procedure should be designed so that it uses those registers • Another way is by using stack • Push the parameters to the stack and call the procedure • The procedure should be designed so that it receives parameters from the stack • In either way, the programmer should know the structure of the procedure

  38. Example ORG 100h MOV AL, 1 MOV BL, 2 CALL m2 RET ; return to operating system. m2 PROC MUL BL ; AX = AL * BL. RET ; return to caller. m2 ENDP END

  39. About the Example • The program calculates 24 • The procedure takes its parameters from AL and BL; multiplies them and stores the result into AX • The C equivalent can be thought as the following: short m2(char al, char bl) { short ax = al * bl; return ax; }

  40. Example: Searching • Write a procedure which searches a number in an array of words. The procedure should receive the start address of the array from the SI register, the number to be searched from the BX register, and the number of elements in the array from the CX register. The procedure should return the offset of the number in DI register. If the number is not found, DI should be zero.

  41. Solution (Page 1) include emu8086.inc ORG 100H ; Put some data into 2500H..2514H MOV SI, 2500H MOV AX, 10 MOV CX, 10 LOOP1: MOV [SI], AX INC SI INC SI DEC AX LOOP LOOP1

  42. Solution (Page 2) ; Set the parameters: MOV SI, 2500H ; start address MOV CX, 10 ; number of elements MOV BX, 1 ; number to be searched ; Call the procedure: CALL FIND ; Check whether the number is found or not found: CMP DI, 0 JNE NUMFOUND PRINT 'The number is not found' RET NUMFOUND: PRINT 'The number is found.' RET

  43. Solution (Page 3) FIND PROC L1: MOV AX, [SI]; Read the next element from the array CMP AX, BX; Compare it to the value on AX JE FOUND; If found, jump to FOUND INC SI; If not found, check the next element in the array INC SI; Since the array is a word-array, SI must be increased by 2 LOOP L1 ; If this line is achieved, the number is not found in the array: JMP NOTFOUND FOUND: MOV DI, SI; Copy SI into DI and return RET NOTFOUND: MOV DI, 0; Copy zero to DI and return RET FIND ENDP

  44. Macros • Macros are just like procedures, but not really • Macros look like procedures, but they exist only until your code is compiled • After compilation all macros are replaced with real instructions • If you declared a macro and never used it in your code, compiler will simply ignore it.

  45. Macro Definition name MACRO [parameters,...] <instructions> ENDM

  46. MyMacro MACRO p1, p2, p3 MOV AX, p1 MOV BX, p2 MOV CX, p3 ENDM ORG 100h MyMacro 1, 2, 3 MyMacro 4, 5, DX RET The code on the left is expanded into: MOV AX, 00001hMOV BX, 00002hMOV CX, 00003hMOV AX, 00004hMOV BX, 00005hMOV CX, DX • Unlike procedures, macros should be defined above the code that uses it.

  47. Macros and Procedures • When you want to use a procedure you should use CALL instruction, for example: CALL MyProc • When you want to use a macro, you can just type its name. For example: MyMacro • You should use stack or any general purpose registers to pass parameters to procedure. • To pass parameters to macro, you can just type them after the macro name. For example: MyMacro 1, 2, 3

  48. Macros and Procedures • Macros end with ENDM directive and procedures end with ENDP directive. • Procedures are located at some specific address in memory but macros are expanded directly in program's code.

  49. Labels in Macros • Macros are expanded directly in code, therefore if there are labels inside the macro definition you may get "Duplicate declaration" error when macro is used for twice or more. • To avoid such problem, use LOCAL directive followed by names of variables, labels or procedure names.

  50. Example MyMacro2 MACRO LOCAL label1, label2 CMP AX, 2 JE label1 CMP AX, 3 JE label2 label1: INC AX label2: ADD AX, 2 ENDM ORG 100h MyMacro2 MyMacro2 RET

More Related