Practical Session 1

Computer Architecture and

Assembly Language

• Byte – sequence of 8 bits:

16 35 4 07 2

MSB (Most Significant Bit) LSB (Least Significant Bit)

• Bit – basic information unit: (1/0)

• Word – a sequence of bits addressed as a single entity by the computer

byte byte 16 bit word

• Main Memory is an array of bytes,

addressed by 0 to 232-1=0xFFFFFFFF

232 bytes = 4∙210∙3 bytes = 4 G bytes

…

…

232-1

2K-1

1

0

address

spacephysical

memory

Data Representation Basics

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

Registers

Note that the list of registers above is partial. The full list can be found here.

Register file

High byte Low byteExtended

16-bit register

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

optional fieldseither required or forbidden by an

instruction

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

Examples:

mov ax, 2 ; moves constant 2 to the register ax

buffer: resb 64 ; reserves 64 bytes

Basic Assembly Instruction Structure

• 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

RAM

64 b

yte

s

2048

mov buffer, 2 = mov 2048, 2

mov [buffer], 2 = mov [2048], 2

mov byte [buffer], 2= mov byte [2048], 2

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

Instruction Arguments

mov [var1],[var2]! Note that x86 processor does not

allow both operands be memory locations.

Examples:

mov ax, 2 mov [buffer], ax

source operand target operand

immediateregistersource operand target operand

registermemory location

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))

MOV - Move Instruction – copies source to destination

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.

operands have to be of

the same size

Examples:

mov eax, 0x2334AAFF mov [buffer], ax mov word [var], 2

imm32reg32reg16mem16 imm16mem16

ADD - add integers

Example:

add 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)

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)

SUB - subtract integers

Example:

sub AX, BX ;(AX gets a value of AX-BX)

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

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 bmov bl, 00000010b

or AL, BL ;(AL gets a value 11111110b)

<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)

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 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)

CMP – Compare Instruction – compares integers

Examples:

mov al, 11111100b

mov bl, 00000010b

cmp al, bl ;(ZF (zero flag) gets a value 0)

CMP performs a ‘mental’ subtraction - affects the flags as if the subtraction had

taken place, but does not store the result of the subtraction.

mov al, 11111100b

mov bl, 11111100 bcmp al, bl ;(ZF (zero flag) gets a value 1)

JMP tells the processor that the next instruction to be executed is located

at the label that is given as part of jmp instruction.

JMP – unconditional jump

jmp label

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

• 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

J<Condition> – conditional jump

j<cond> label

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:

mov eax, 1

inc_again:

inc eax

cmp eax, 10

jne inc_again ; if eax ! = 10, go back to loop

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

Jcc: Conditional Branch

d<size> – declare initialized data

d<size> initial value

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

<size> value<size> filedPseudo-instruction

1 bytebyteDB

2 byteswordDW

4 bytesdouble wordDD

8 bytesquadwordDQ

10 bytestenbyteDT

16 bytesdouble quadwordDDQ

16 bytesoctowordDO

Assignment 0

You get a simple program that receives a string from the user.

Than, it calls to a function (that you’ll implement in assembly) that receives

one string as an argument and should do the following:

• Convert lower case to upper case.

• Convert ‘(’ into ‘<’.

• Convert ‘)’ into ‘>’.

• Count the number of the non-letter characters, that is ANY character that is not 'a'->'z' or 'A'->'Z‘, including ‘\n’ character

The function shall return the number of the letter characters in the string.

The characters conversion should be in-place.

> 42: heLL() WorLd!

> 42: HELL<> WORLD!

> 9

Example:

#include <stdio.h>

# define MAX_LEN 100 /* Maximal line size */

extern int do_Str (char*);

int main(void) {

char str_buf[MAX_LEN];

int counter = 0;

fgets(str_buf, MAX_LEN, stdin); /* Read user's command line string */

counter = do_Str (str_buf); /* Your assembly code function */

printf("%s%d\n",str_buf,counter);

return 0;

}

main.c

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 do_Str ; makes the function appear in global scope

extern printf ; tell linker that printf is defined elsewhere ; (not used in the program)

do_Str: ; 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

myasm.s

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

Running NASM

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 nameand 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