Computer Architecture and Assembly Language Practical Session 1 Data Representation Basics • Bit – basic information unit: (1/0) • Byte – sequence of 8 bits: 7 6 5 4 3 2 1 0 MSB (Most Significant Bit) LSB (Least Significant Bit) 232-1 • Main Memory is an array of bytes, … addressed by 0 to 232-1=0xFFFFFFFF 2K-1 232 bytes = 4∙210∙3 bytes = 4 G bytes address … space 1 physical memory 0 • Word – a sequence of bits addressed as a single entity by the computer byte byte 16 bit word Registers Register file - CPU unit which contains (32 bit) registers. general purpose registers Register file EAX, EBX, ECX, EDX (Accumulator, Base, Counter, Data) index registers ESP, EBP, ESI, EDI (Stack pointer - contains the address of last used dword in the stack, Base pointer, Source index, Destination Index) flag register / status register EFLAGS Extended High byte Low byte 16-bit register Instruction Pointer / Program Counter EIP / EPC - contains address (offset) of the next instruction that is going to be executed (at run time) - changed by unconditional jump, conditional jump, procedure call, and return instructions Note that the list of registers above is partial. The full list can be found here. Assembly Language Program • consists of a series of processor instructions, meta-statements, comments, and data • translated by assembler into machine language instructions (binary code) that can be loaded into memory and executed • NASM - Netwide Assembler - is assembler and for x86 architecture Example: assembly code: MOV AL, 61h ; load AL with 97 decimal (61 hex) binary code: 10110000 01100001 1011 a binary code (opcode) of instruction 'MOV' 0 specifies if data is byte (‘0’) or full size 16/32 bits (‘1’) 000 a binary identifier for a register 'AL' 01100001 a binary representation of 97 decimal (97d = (int)(97/16)*10 + (97%16 converted to hex digit) = 61h) Basic Assembly Instruction Structure label: (pseudo) instruction operands ; comment either required or forbidden by an optional fields instruction RAM • each instruction has its offset (address) • we mark an instruction with a label to refer it in the code • (non-local) labels have to be unique buffer 2048 • an instruction that follows a label can be at the same / next line • colon is optional bytes 64 Examples: … mov ax, 2 ; moves constant 2 to the register ax buffer: resb 64 ; reserves 64 bytes Notes: mov buffer, 2 = mov 2048, 2 - backslash (\) : if a line ends with backslash, the next line is considered to be a part of the backslash-ended line mov [buffer], 2 = mov [2048], 2 - no restrictions on white space within a line mov byte [buffer], 2= mov byte [2048], 2 Instruction Arguments A typical instruction has 2 operands - target operand (left) - source operand (right) 3 kinds of operands exists - immediate : value - register : AX,EBP,DL etc. - memory location : variable or pointer Examples: mov ax, 2 mov [buffer], ax target operand source operand target operand source operand register immediate memory location register ! Note that x86 processor does not mov [var1],[var2] allow both operands be memory locations. MOV - Move Instruction – copies source to destination mov reg8/mem8(16,32),reg8/imm8(16,32) (copies content of register / immediate (source) to register / memory location (destination)) mov reg8(16,32),reg8/mem8(16,32) (copies content of register / memory location (source) to register (destination)) operands have to be of the same size Examples: mov eax, 0x2334AAFF mov [buffer], ax mov word [var], 2 reg32 imm32 mem16 reg16 mem16 imm16 Note that NASM doesn’t remember the types of variables you declare . It will deliberately remember nothing about the symbol var except where it begins, and so you must explicitly code mov word [var], 2. Basic Arithmetical Instruction <instruction> reg8/mem8(16,32),reg8/imm8(16,32) (source - register / immediate, destination- register / memory location) <instruction> reg8(16,32),reg8/mem8(16,32) (source - register / immediate, destination - register / memory location) ADD - add integers SUB - subtract integers Example: Example: add AX, BX ;(AX gets a value of AX+BX) sub AX, BX ;(AX gets a value of AX-BX) ADC - add integers with carry SBB - subtract with borrow (value of Carry Flag) (value of Carry Flag) Example: Example: adc AX, BX ;(AX gets a value of AX+BX+CF) sbb AX, BX ;(AX gets a value of AX-BX-CF) Basic Arithmetical Instruction <instruction> reg8/mem8(16,32) (source / destination - register / memory location) INC - increment integer Example: inc AX ;(AX gets a value of AX+1) DEC - increment integer Example: dec byte [buffer] ;([buffer] gets a value of [buffer] -1) Basic Logical Instructions <instruction> reg8/mem8(16,32) (source / destination - register / memory location) NOT – one’s complement negation – inverts all the bits Example: mov al, 11111110b not al ;(AL gets a value of 00000001b) ;(11111110b + 00000001b = 11111111b) NEG – two’s complement negation – inverts all the bits, and adds 1 Example: mov al, 11111110b neg al ;(AL gets a value of not(11111110b)+1=00000001b+1=00000010b) ;(11111110b + 00000010b = 100000000b = 0) Basic Logical Instructions <instruction> reg8/mem8(16,32),reg8/imm8(16,32) (source - register / immediate, destination- register / memory location) <instruction> reg8(16,32),reg8/mem8(16,32) (source - register / immediate, destination - register / memory location) OR – bitwise or – bit at index i of the destination gets ‘1’ if bit at index i of source or destination are ‘1’; otherwise ‘0’ Example: mov al, 11111100 b mov bl, 00000010b or AL, BL ;(AL gets a value 11111110b) AND– bitwise and – bit at index i of the destination gets ‘1’ if bits at index i of both source and destination are ‘1’; otherwise ‘0’ Example: or AL, BL ;(with same values of AL and BL as in previous example, AL gets a value 0) CMP – Compare Instruction – compares integers CMP performs a ‘mental’ subtraction - affects the flags as if the subtraction had taken place, but does not store the result of the subtraction. cmp reg8/mem8(16,32),reg8/imm8(16,32) (source - register / immediate, destination- register / memory location) cmp reg8(16,32),reg8/mem8(16,32) (source - register / immediate, destination - register / memory location) Examples: mov al, 11111100 mov al, 11111100b b mov bl, 11111100 mov bl, 00000010b b cmp al, bl ;(ZF (zero flag) gets a value 0) cmp al, bl ;(ZF (zero flag) gets a value 1) JMP – unconditional jump jmp label JMP tells the processor that the next instruction to be executed is located at the label that is given as part of jmp instruction. Example: this is infinite loop ! mov eax, 1 inc_again: this instruction is never inc eax reached from this code jmp inc_again mov ebx, eax J<Condition> – conditional jump j<cond> label • execution is transferred to the target instruction only if the specified condition is satisfied • usually, the condition being tested is the result of the last arithmetic or logic operation mov eax, 1 Example: inc_again: inc eax mov eax, 1 cmp eax, 10 inc_again: jne inc_again ; if eax ! = 10, go back to loop inc eax cmp eax, 10 je end_of_loop ; if eax = = 10, jump to end_of_loop jmp inc_again ; go back to loop end_of_loop: Jcc: Conditional Branch Instruction Description Flags JO Jump if overflow OF = 1 JNO Jump if not overflow OF = 0 JS Jump if sign SF = 1 JNS Jump if not sign SF = 0 JE Jump if equal ZF = 1 JZ Jump if zero JNE Jump if not equal ZF = 0 JNZ Jump if not zero JB Jump if below CF = 1 JNAE Jump if not above or equal JC Jump if carry JNB Jump if not below CF = 0 JAE Jump if above or equal JNC Jump if not carry JBE Jump if below or equal CF = 1 or ZF = 1 JNA Jump if not above JA Jump if above CF = 0 and ZF = 0 JNBE Jump if not below or equal JL Jump if less SF <> OF JNGE Jump if not greater or equal JGE Jump if greater or equal SF = OF JNL Jump if not less JLE Jump if less or equal ZF = 1 or SF <> OF JNG Jump if not greater JG Jump if greater ZF = 0 and SF = OF JNLE Jump if not less or equal JP Jump if parity PF = 1 JPE Jump if parity even JNP Jump if not parity PF = 0 JPO Jump if parity odd JCXZ Jump if CX register is 0 CX = 0 JECXZ Jump if ECX register is 0 ECX = 0 d<size> – declare initialized data d<size> initial value Pseudo-instruction <size> filed <size> value DB byte 1 byte DW word 2 bytes DD double word 4 bytes DQ quadword 8 bytes DT tenbyte 10 bytes DDQ double quadword 16 bytes DO octoword 16 bytes Examples: var: db 0x55 ; define a variable ‘var’ of size byte, initialized by 0x55 var: db 0x55,0x56,0x57 ; three bytes in succession var: db 'a‘ ; character constant 0x61 (ascii code of ‘a’) var: db 'hello',13,10,'$‘ ; string constant var: dw 0x1234 ; 0x34 0x12 var: dw ‘A' ; 0x41 0x00 – complete to word var: dw ‘AB‘ ; 0x41 0x42 var: dw ‘ABC' ; 0x41 0x42 0x43 0x00 – complete to word var: dd 0x12345678 ; 0x78 0x56 0x34 0x12 Assignment 0 You get a simple program that receives a string from a user. Then, this program calls to a function (that you should implement in assembly) that receives a string as an argument and does the following: 1. let n - the fourth digit in the smaller id (of the partners’ ids), if n = 0 then you take the next digit in the id. (1<=n<=9) 2. Add n to each character of the input string to get the result string. 3. Count the number of letters in the input string that are converted to non-letter character in the result string.