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 MSB (Most Significant Bit) LSB (Least Significant Bit) 232-1 2K-1 1 … Main Memory is an array of bytes, addressed by 0 to 232-1=0xFFFFFFFF 232 bytes = 4∙210∙3 bytes = 4 G bytes address space physical memory 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 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 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 Register file High byte Low byte Extended 16-bit register 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)

label: (pseudo) instruction operands ; comment Basic Assembly Instruction Structure label: (pseudo) instruction operands ; comment either required or forbidden by an instruction optional fields 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 an instruction that follows a label can be at the same / next line colon is optional … buffer 2048 64 bytes Examples: mov ax, 2 ; moves constant 2 to the register ax buffer: resb 64 ; reserves 64 bytes  Notes: - backslash (\) : if a line ends with backslash, the next line is considered to be a part of the backslash-ended line - no restrictions on white space within a line mov buffer, 2 = mov 2048, 2  mov [buffer], 2 = mov [2048], 2  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 allow both operands be memory locations. mov [var1],[var2]

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 Example: add AX, BX ;(AX gets a value of AX+BX) SUB - subtract integers Example: sub AX, BX ;(AX gets a value of AX-BX) ADC - add integers with carry (value of Carry Flag) Example: adc AX, BX ;(AX gets a value of AX+BX+CF) SBB - subtract with borrow (value of Carry Flag) Example: 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, 11111100b mov bl, 00000010b cmp al, bl ;(ZF (zero flag) gets a value 0) mov al, 11111100b mov bl, 11111100 b 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: mov eax, 1 inc_again: inc eax jmp inc_again mov ebx, eax this is infinite loop ! this instruction is never reached from this code

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 inc_again: inc eax cmp eax, 10 jne inc_again ; if eax ! = 10, go back to loop Example: mov eax, 1 inc_again: 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  JZ Jump if equal  Jump if zero ZF = 1 JNE  JNZ Jump if not equal  Jump if not zero ZF = 0 JB  JNAE  JC Jump if below  Jump if not above or equal  Jump if carry CF = 1 JNB  JAE  JNC Jump if not below  Jump if above or equal  Jump if not carry CF = 0 JBE  JNA Jump if below or equal  Jump if not above CF = 1 or ZF = 1 JA  JNBE Jump if above  Jump if not below or equal CF = 0 and ZF = 0 JL  JNGE Jump if less  Jump if not greater or equal SF <> OF JGE  JNL Jump if greater or equal  Jump if not less SF = OF JLE  JNG Jump if less or equal  Jump if not greater ZF = 1 or SF <> OF JG  JNLE Jump if greater  Jump if not less or equal ZF = 0 and SF = OF JP  JPE Jump if parity  Jump if parity even PF = 1 JNP  JPO Jump if not parity  Jump if parity odd PF = 0 JCXZ  JECXZ Jump if CX register is 0  Jump if ECX register is 0 CX = 0  ECX = 0

d<size> – declare initialized data d<size> initial value <size> value <size> filed Pseudo-instruction 1 byte byte DB 2 bytes word DW 4 bytes double word DD 8 bytes quadword DQ 10 bytes tenbyte DT 16 bytes double quadword DDQ octoword DO 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: 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) Add n to each character of the input string to get the result string. Count the number of letters in the input string that are converted to non-letter character in the result string. The function returns the result string and the counter. The characters conversion should be in-place. examples: > abcd > efgh > 0 > stuvwxyz > wxyz{|}~ > 4

main.c #include <stdio.h> # define MAX_LEN 100 // Maximal line size extern int strToLeet (char*); int main(void) { char str_buf[MAX_LEN]; int count= 0; fgets(str_buf, MAX_LEN, stdin); // Read user's command line string count = add_Str_N (str_buf); // Your assembly code function printf("%s\n%d\n",str_buf,count); }

myasm.s section .data ; data section, read-write an: DD 0 ; this is a temporary var section .text ; our code is always in the .text section global add_Str_N ; makes the function appear in global scope extern printf ; tell linker that printf is defined elsewhere ; (not used in the program) add_Str_N: ; functions are defined as labels push ebp ; save Base Pointer (bp) original value mov ebp, esp ; use base pointer to access stack contents pushad ; push all variables onto stack mov ecx, dword [ebp+8] ; get function argument ;;;;;;;;;;;;;;;; FUNCTION EFFECTIVE CODE STARTS HERE ;;;;;;;;;;;;;;;; mov dword [an], 0 ; initialize answer label_here: ; Your code goes somewhere around here... inc ecx ; increment pointer cmp byte [ecx], 0 ; check if byte pointed to is zero jnz label_here ; keep looping until it is null terminated ;;;;;;;;;;;;;;;; FUNCTION EFFECTIVE CODE ENDS HERE ;;;;;;;;;;;;;;;; popad ; restore all previously used registers mov eax,[an] ; return an (returned values are in eax) mov esp, ebp pop ebp ret

Running NASM To assemble a file, you issue a command of the form > nasm -f <format> <filename> [-o <output>] [ -l listing] Example: > nasm -f elf myasm.s -o myelf.o It would create myelf.o file that has elf format (executable and linkable format). We use main.c file (that is written in C language) to start our program, and sometimes also for input / output from a user. So to compile main.c with our assembly file we should execute the following command: gcc –m32 main.c myelf.o -o myexe.out The -m32 option is being used to comply with 32- bit environment It would create executable file myexe.out. In order to run it you should write its name on the command line: > myexe.out

Example (n=4)

How to run Linux from Window Go to http://www.chiark.greenend.org.uk/~sgtatham/putty/download.html Run the following executable Use “lvs.cs.bgu.ac.il” or “lace.cs.bgu.ac.il” host name and click ‘Open’ Use your Linux username and password to login lace server Go to http://www.cs.bgu.ac.il/facilities/labs.html Choose any free Linux computer Connect to the chosen computer by using “ssh –X cs302six1-4” (maybe you would be asked for your password again) cd (change directory) to your working directory

Ascii table