Chapter1c

364 views
296 views

Published on

Published in: Education, Technology
0 Comments
0 Likes
Statistics
Notes
  • Be the first to comment

  • Be the first to like this

No Downloads
Views
Total views
364
On SlideShare
0
From Embeds
0
Number of Embeds
0
Actions
Shares
0
Downloads
2
Comments
0
Likes
0
Embeds 0
No embeds

No notes for slide

Chapter1c

  1. 1. I. INTRODUCTIONDeveloping Assembly LanguagePrograms
  2. 2. Instructions and Directives Instructions  tell processor what to do  assembled into machine code by assembler  executed at runtime by the processor  from the Intel x86 instruction set
  3. 3. Instructions and Directives Directives  tell assembler what to do  commands that are recognized and acted upon by the assembler  not part of the instruction set  used to declare code and data areas, define constants and memory for storage  different assemblers have different directives
  4. 4. Assembler Directives EQU directive  defines constants – label equ value – count equ 100 Data definition directive  defines memory for data storage  defines size of data
  5. 5. Assembler Directives Initialized Data  db – define byte  dw – define word  dd – define double – label directive initial value – int db 0 – num dw 100
  6. 6. Assembler Directives Character constants  single quote delimited  ‘A’ – char db ‘!’
  7. 7. Assembler Directives String constants  single quote delimited or sequence of characters separated by commas  each character is one byte each  ‘hello’  ‘h’, ’e’, ’l’, ’l’, ’o’ – prompt1 db ‘Please enter number: ’ – prompt2 db ‘Please enter number: ’,10
  8. 8. Assembler Directives Declarations
  9. 9. Assembler Directives Uninitialized Data  resb – reserve byte  resw – reserve word  resd – reserve double word – label directive value – num resb 1 ; reserves 1 byte – nums resb 10 ; reserves 10 bytes
  10. 10. Assembler Directives Uninitialized variables
  11. 11. Assembly Instructions Basic Format instruction operand1, operand2 Operand  Register  Immediate  Memory
  12. 12. Instruction Operands Registers  eax, ax, ah, al  ebx, bx, bh, bl  ecx, cx, ch, cl  edx, dx, dh, dl
  13. 13. Instruction Operands Immediate  character constants – character symbols enclosed in quotes – character ASCII code  integer constants – begin with a number – ends with base modifier (B, O or H)  ‘A’ = 65 = 41H = 01000001B
  14. 14. Instruction Operands Memory  when using the value of a variable, enclose the variable name in square brackets  [num] - value of num  num - address of num
  15. 15. Instruction Operands  If the operands are registers or memory locations, they must be of the same type.  Two memory operands are not allowed in an instruction.
  16. 16. LABORATORY TOPICSBasic Input/Output
  17. 17. Basic Input/Output Interrupts  can be a hardware or software interrupt  the printer is out of paper – hardware interrupt  assembly program issuing a system call – software interrupt An interrupt simply gets the attention of the processor so that it would context switch and execute the systems interrupt handler being invoked.
  18. 18. Basic Input/Output Interrupts  break the program execution cycle (Fetch-Decode-Execute)  wait for interrupt to be serviced Linux services  int 0x80, int 80H – function calls
  19. 19. INT 80H system call numbers for this service are placed in EAX  1 – sys_exit (system exit)  3 – sys_read (read from standard input)  4 – sys_write (write to standard output)
  20. 20. INT 80H mov eax, 1 mov ebx, 0 int 80H  terminate program  return 0 at the end of main program (no error)
  21. 21. INT 80H mov eax, 3 mov ebx, 0 mov ecx, <address> int 80H  reads user input  stores input to a variable referenced by address
  22. 22. INT 80H mov eax, 4 mov ebx, 1 mov ecx, <string> mov edx, <length> int 80H  outputs a character/string  character/string must be in ECX and string length must be in EDX before issuing interrupt
  23. 23. Basic Input/Output Instructions
  24. 24. Basic Input/Output
  25. 25. Basic Input/Output
  26. 26. Basic Input/Output
  27. 27. Basic Input/Output
  28. 28. Basic Input/Output
  29. 29. Converting Characters to Numbers  Input read from the keyboard are ASCII- coded characters.  Output displayed on screen are ASCII- coded characters.  To perform arithmetic, a numeric character must be converted from ASCII to its equivalent value.  To print an integer, a number must be converted to its equivalent ASCII character(s).
  30. 30. Converting Characters to Numbers Character to Number: section .bss num resb 1 section .text mov eax, 3 mov ebx, 0 mov ecx, num int 80h
  31. 31. Converting Characters to Numbers Character to Number: section .bss num resb 1 section .text mov eax, 3 mov ebx, 0 mov ecx, num int 80h sub [num], 30h
  32. 32. Converting Numbers to Characters Number to Character: section .text mov eax, 4 mov ebx, 1 mov ecx, num mov edx, 1 int 80h
  33. 33. Converting Numbers to Characters Number to Character: section .text add [num], 30h mov eax, 4 mov ebx, 1 mov ecx, num mov edx, 1 int 80h
  34. 34. ASCII Table
  35. 35. ASCII Table
  36. 36. Converting Characters to Numbers Character to Number: mov ecx, num int 80h sub [num], 30h num = 0 0 1 1 0 1 0 0 30h = 0 0 1 1 0 0 0 0 num = 0 0 0 0 0 1 0 0
  37. 37. Converting Numbers to Characters Number to Character: add [num], 30h num = 0 0 0 0 0 1 1 0 30h = 0 0 1 1 0 0 0 0 num = 0 0 1 1 0 1 1 0
  38. 38. LABORATORY TOPICSImplementing SequentialStatements
  39. 39. Assignment Instruction  mov instruction mov destination, source  mov is a storage command  copies a value into a location  destination may be register or memory  source may be register, memory or immediate  operands should not be both memory  operands must be of the same size
  40. 40. Simple Instructions  inc destination – increase destination by 1  dec destination – decrease destination by 1  neg destination – negate destination (2’s complement)  destination may be a register or a memory
  41. 41. Add and Sub Instructions  add destination, source destination = destination + source  sub destination, source destination = destination – source  same restrictions as the mov instruction
  42. 42. Multiplication  mul source  Source is the multiplier  Source may be a register or memory  If source is byte-size then AX = AL * source  If source is word-size then DX:AX = AX * source  If source is double word-size then EDX:EAX = EAX * source
  43. 43. Multiplication mov al, 2 mov [num], 80H mul byte [num]
  44. 44. Multiplication mov al, 2 mov [num], 80H mul byte [num]  This results in AX = 2 * 128 = 256 = 0100 H
  45. 45. Multiplication mov al, 2 mov [num], 80H mul byte [num]  This results in AX = 2 * 128 = 256 = 0100 H  In Binary, AX = 0000000100000000 B
  46. 46. Multiplication mov al, 2 mov [num], 80H mul byte [num]  This results in AX = 2 * 128 = 256 = 0100 H  In Binary, AX = 0000000100000000 B  So, AH = 1 and AL = 0.
  47. 47. Multiplication mov ax, 2 mov [num], 65535 mul word [num]  This results in 2 * 65535 = 131070 = 0001FFFE H.  DX = 1 and AX = FFFE H  Only when taken together will one get the correct product.
  48. 48. Division  div source  Source is the divisor  Source may be a register or memory  If source is byte-size then AH = AX mod source AL = AX div source
  49. 49. Division  If source is word-size then DX = DX:AX mod source AX = DX:AX div source  If source is double word-size then EDX = EDX:EAX mod source EAX = EDX:EAX div source  div == integer division  mod == modulus operation (remainder)
  50. 50. Division (Divide word by byte) mov ax, 257 mov [num], 2 div byte [num]
  51. 51. Division (Divide word by byte) mov ax, 257 mov [num], 2 div byte [num]  This results in AH = 1 and AL = 128
  52. 52. Division (Divide byte by byte) mov [num], 129 mov al, [num] mov ah, 0 mov [num], 2 div byte [num]
  53. 53. Division (Divide byte by byte) mov [num], 129 mov al, [num] mov ah, 0 mov [num], 2 div byte [num]  AX = 129 since AH = 0 and AL = 129
  54. 54. Division (Divide byte by byte) mov [num], 129 mov al, [num] mov ah, 0 mov [num], 2 div byte [num]  AX = 129 since AH = 0 and AL = 129  This results in AH = 1 and AL = 64
  55. 55. Division (Divide word by word) mov dx, 0 mov ax, 65535 mov [num], 32767 div word [num]  DX:AX = 65535  num = 32767  This results in DX = 1 and AX = 2.
  56. 56. Division (Divide word by word) mov dx, 1 mov ax, 65535 mov [num], 65535 div word [num]  Taken together the values in DX and AX is 131071.  This is divided by 65535.  The results are in DX = 1 and in AX = 2.
  57. 57. Divide Overflow Error mov ax, 65535 mov [num], 2 div byte [num]  Dividing 65535 by 2 results in a quotient of 32767 with a remainder of 1.  The value 32767 will not fit in AL, the destination of the quotient, thus resulting in an error.

×