Language of x86 processor family

Transcription

1 Assembler lecture 2 S.Šimoňák, DCI FEEI TU of Košice Language of x86 processor family Assembler commands: instructions (processor, instructions of machine language) directives (compiler translation control, not a machine language instructions generation) macros (group of commands, compilation-time substitution expansion) Command format: [label] mnemonics [operands] [;comment] label (separated by : from mnemonics, not in case of directives) repeat: inc count ;increase 'count' 1 CR EQU 0DH ;carriage return Data objects allocation HLL indirectly, by specifying variable type (int sum;) except the space allocation, a way of interpretation given too (unsigned s1 vs. int s2; 4B both) assembler allocation, and initialisation respectively (not interpretation), format: [variable] directive init.value [, init.value] allocation directives (with initialization): DB (define byte, 1B), DW (define word, 2B), DD (define doubleword, 4B), DQ (define quadword, 8B), DT (def. ten bytes, 10B)

2 sorted DB 'y' (the same: sorted DB 79H) value DW (6247H, Little endian: 47, 62) expr1 DW 7*25 (initialisation by expression) range of values (signed and unsigned numbers) allocation directives (without initialization) - RESB (reserve byte, 1B), RESW (2B), RESD (4B), RESQ (8B), REST (10B) buffer resw 100 (array of 100 words) Multiple definitions continuous memory block allocation for sequence of definitions message DB 'BYE', 0DH, 0AH directive TIMES multiple initialization to the same value (arrays) marks TIMES 8 DW 0 Operands most instructions require operands addressing a way of specifying operand location basic operand types (details later): register (register CPU contains data, speed) EAX, EBX

3 immediate (datum directly within instruction code segment) AL, 65 (source immediate, dest - register) memory (effective address (offset): part of instruction direct, in register indirect) address vs. value (NASM: EBX, table, resp. EBX, [table]) table TIMES 20 DD 0... [table], 'A' ; direct memory addressing EBX, table ; indirect memory addressing [EBX], 100 ; table[0] = 100 (size of data?) add EBX, 4 ; table item 4B (DD) [EBX], 99 ; table[1] = 99 implicit operand stc, clc, pusha, popa,... Basic instructions of Pentium processor language reference guide (e.g. [2, 3]) Data transfer instructions instruction MOV (copy), usage rules (src unchanged, same operand size) syntax dst, src (dst src)

4 operand combinations (R register, M memory, I - immediate) R, R R, M R, I ( EAX, 3) M, R M, I M, M combination not allowed! (explicit) data size specification (BYTE, WORD, DWORD, QWORD, TBYTE) [EBX], 100 BYTE [EBX], 100 WORD [EBX], 100 ; data size not clear ; write 1B ; write 2B instruction XCHG (exchange) operand exchange, syntax xchg dst, src (dst src) rules (both operands in memory not allowed) exchange without auxiliary register (sorting, little/big endian) ECX, EAX vs. xchg EAX, EDX EAX, EDX EDX, ECX instruction XLAT (translate) character translation, syntax xlat usage input: EBX table starting address, AL index output: AL (byte from the resulting address)

5 Arithmetic operations instructions INC and DEC increasing/decreasing operand value (8, 16, 32-bit; register/memory) by 1, syntax inc dst dec dst count DW 0 value DB 25.code inc [count] EBX,count inc [EBX] inc WORD [EBX] (inc EBX) (dec DL) ; OK (type 'count' known) ; ambiguity ; OK instruction ADD addition 8, 16, 32-bit operands, syntax add dst, src (dst dst + src) rules (like MOV instruction) INC vs. ADD (preferred INC less memory) inc EAX vs. add EAX, 1 instruction SUB subtraction 8, 16, 32-bit operands, syntax sub dst, src (dst dst - src) instruction CMP similarly like SUB, but result not stored ('dst' unchanged, setting flags) typical usage conditional jumps

6 Jumps and iterations unconditional jump JMP passing the control to label jmp label (EIP label) conditional jumps program execution transferred to label (at satisfied condition) j<cond> label cmp AL, 0DH je CD_received ; jump on equal register FLAGS (ZF = 1 when CMP operands are equal) not all the instructions affect flags (MOV) conditions simple test of flag value (jz, jnz, jc, jnc, ) more complex conditions (jg, jl, jge, jle, ) iterations can also be realized with jumps direct iterations support LOOP syntax loop label operation (ECX counter): ECX = ECX 1 if ECX 0 then EIP label

7 Logical operations instructions AND, OR, XOR, NOT syntax and dst, src not dst (or, xor) (unary operator) truth tables and 0 1 or 0 1 xor operations AND, OR, XOR, NOT [1] logical operations usage

8 instruction TEST if operand modification is a problem performs bit operation AND (like and instruction), sets flags in the same way, without operand modification test AL, 01H ;can be used in previous example instead of: and AL, 01H shifts SHL (shift left) one bit left (CF MSB, LSB 0) SHR (shift right) one bit right (CF LSB, MSB 0) syntax (shl, shr), dst (8, 16, 32-bit M/R) shl dst, count shl dst, CL ; direct shift specification(0-31) ; indirect, in CL register usage of shift operations (LSb, CF)

9 rotations lost of bits when shifts are used sometimes unwanted rotations without CF instructions ROL, ROR last bit shifted out captured in CF syntax (ROL, ROR) rol dst, count rol dst, CL ROL rotation left; bits falling off on the left placed on the right side (D i+1 D i, LSB MSB, CF MSB) ROR rotation right; bits falling off on the right placed on the left side (D i D i+1, MSB LSB, CF LSB) rotations through CF instructions RCL, RCR CF involved in rotation process, syntax (like ROL, ROR) RCL rotation left; bit rotated out goes into CF, CF enters from right side (D i+1 D i, CF MSB, LSB CF) RCR rotation right; bit rotated out goes into CF, CF enters from left side (D i D i+1, CF LSB, MSB CF) using rotations with multiword shifts (64-bit, EDX:EAX by 1 bit right) shr EDX, 1 rcr EAX, 1

10 Constants and Macros NASM offers several possibilities, we will discuss 3 directives: directive EQU syntax name EQU expr usage assigning the value of 'expr' to the 'name' (where expr can be evaluated in compile time) advantages: program readability, multiple constant occurrence changing at one place values assigned can not be changed within a source module directive %assign - like EQU (defining numerical constants), but redefinition possible %assign i j+1 <code fragment> %assign i j+2 directive %define - numerical and string constants, redefinition possible %define X1 [EBP+4] <code fragment> %define X1 [EBP+20]

11 Macros block of text represented by name when name occurs in program replaced by the corresponding block (macro expansion) %macro macro_name <macro body> %endmacro para_count calling the macro name of macro with corresponding parameters macros without parameters definition: calling macro: after macro expansion: %macro multeax_by_ sal EAX, 4 EAX, 27 EAX, 27 %endmacro multeax_by_16 sal EAX, macros with parameters - generalization of macro in macro body parameters accessed by the order (%1) definition: calling macro: after macro expansion: %macro mult_by_ sal %1, 4 mult_by_16 DL sal DL, 4 %endmacro......

12 Assembly programming assembling - translation of AL program into machine code linking - linking the machine code and data in object files and libraries executable file debugging Input and output non-existence of standard mechanism in AL programming (system dependent) solutions direct HW access operating system services standard libraries of HLL within our course used [2] sub-programs for simplifying basic I/O operations (C library used) print_int (integer value in EAX) print_char (ASCII in AL) print_string (address in EAX, null terminator) print_nl (new line) read_int (stored in EAX) read_char (ASCII into EAX) register contents preserved (read* - modify EAX) usage %include asm_io.inc calling operations (call)

13 Debugging method used within course [2] displaying the state of computer (without modification) macros defined in asm_io.inc operations: dump_regs (HEX dump of registers, FLAGS, argument dump number) dump_mem (HEX/ASCII dump of memory, arg1 dump number, arg2 address, arg3 number of 16B blocks) dump_stack (stack content, arg1 dump number, arg2 # doublewords under EBP, arg3 # doublewords over EBP) dump_math (values in FPU registers, argument dump number) C language and AL programming programs seldom written in pure AL (HLL benefits...) more often combination with HLL (e.g. C) critical parts in AL (speed, HW access,...) start of (AL) program from C-driver, motivation: switch to protected mode (SR initialized, tables in memory) access to standard C-library (I/O, )

14 Sample program driver in C (driver.c) int main() { int ret_status; ret_status = asm_main(); return ret_status; } assembly program segment.data (initialized, strings terminated by 0) segment.bss (non-initialized, if required, e.g. stack) segment.text (program code) _asm_main (C-calling convention; all C symbols (functions, global variables) prefix '_' (DOS/Win),...) global _asm_main (creating global label, accessible from all modules) compilation (MinGW/DevCPP) assembler nasm -f win32 -d COFF_TYPE asm_io.asm (asm_io.obj) assembler nasm -f win32 first.asm (first.obj) driver.c gcc -c driver.c (driver.o) linker gcc -o first driver.o first.obj asm_io.obj (gcc calls linker with correct parameters, first.exe) object formats of other C-compilers [3] Study literature: [1] Dandamudi,S.,P.: Introduction to Assembly Language Programming, Springer Science+Business Media, Inc., [2] Carter, A., P.: PC Assembly Language, 2006, [3] NASM - The Netwide Assembler, The NASM Development Team, 2007,

15 ; Objective: HEX value of character entered. ; Input: Char from keyboard. ; Output: Prints ASCII code of char in HEX. %include "asm_io.inc" segment.data char_prompt db "Please input a character: ",0 out_msg1 db "The ASCII code of '",0 out_msg2 db "' in HEX is ",0 segment.text global _asm_main _asm_main: enter 0,0 pusha call call call EAX, char_prompt print_string read_char EBX, EAX print_nl print_digit: cmp AL,9 jg A_to_F ; translation A F add AL,'0' ; translation 0 9 jmp skip A_to_F: add AL,'A'-10 skip: call print_char AL,AH and AL,0FH loop print_digit popa EAX, 0 leave ret call call call shr EAX, out_msg1 print_string EAX, EBX print_char EAX, out_msg2 print_string EAX, EBX AH,AL AL,4 ECX,2