slide1 n.
Skip this Video
Download Presentation
Computer Architecture and Assembly Language

Loading in 2 Seconds...

play fullscreen
1 / 20

Computer Architecture and Assembly Language - PowerPoint PPT Presentation

  • Uploaded on

Computer Architecture and Assembly Language. Byte structure : a byte has 8 bits. 7. 6. 5. 4. 3. 2. 1. 0. MSB (most significant bit) LSB (least significant bit). Registers:. CPU contains a unit called “Register file”.

I am the owner, or an agent authorized to act on behalf of the owner, of the copyrighted work described.
Download Presentation

PowerPoint Slideshow about 'Computer Architecture and Assembly Language' - mackenzie

Download Now An Image/Link below is provided (as is) to download presentation

Download Policy: Content on the Website is provided to you AS IS for your information and personal use and may not be sold / licensed / shared on other websites without getting consent from its author.While downloading, if for some reason you are not able to download a presentation, the publisher may have deleted the file from their server.

- - - - - - - - - - - - - - - - - - - - - - - - - - E N D - - - - - - - - - - - - - - - - - - - - - - - - - -
Presentation Transcript

Byte structure:

a byte has 8 bits









MSB (most significant bit) LSB (least significant bit)



CPU contains a unit called “Register file”.

This unit contains the registers of thefollowing types:

1. 8-bit general registers: AL, BL, CL, DL, AH, BH, CH, DH

2. 16- bit general registers:AX, BX, CX, DX, SP, BP, SI, Dl

3. 32-bit general registers: EAX, EBX, ECX, EDX, ESP, EBP,ESI, EDI (Accumulator, Base, Counter, Data, Stack pointer, Base pointer, Source index, Destination Index)

4. Segment registers: ES, CS ,SS, DS, FS, GS

5. instruction pointer: EIP

Note: the registers above are a partial list. There are more registers.


EIP - instruction pointer:

contains offset (address) of the next instruction that is going to be executed. Exists only during run time. The software change it by performing unconditional jump, conditional jump, procedure call, return.

AX,BX,CX,DX - 16-bit general registers:

contains two 8-bit registers:Example: AH,AL (for AX)

EAX - 32-bit general purpose register: lower 16 bits are AX.

segment registers: we use a flat memory model –32bit 4GB address space, without segments. So for this course you can ignore segment registers.

ESP - stack pointer: contains the next free address on a stack.

high byte

low byte




Basic assembly instructions:

Each NASM standard source line contains a combination of the 4 fields:

label: (pseudo) instructionoperands ; comment

Either required or forbidden by an instruction

optional fields


1. backslash (\) uses as the line continuation character: if a line ends with backslash, the next line is considered to be a part of the backslash-ended line.2. no restrictions on white space within a line.3. a colon after a label is optional.


1. mov ax, 2 ; moves constant 2 to the register ax2. buffer: resb 64 ; reserves 64 bytes

instruction arguments

A typical instruction has 2 operands.

  • The left operand is the target operand, while the right operand is the source operand
  • 3 kinds of operands exists:
  • Immediate, i.e. a value
  • Register, such as AX,EBP,DL
  • Memory location; a variable or a pointer.
  • One should notice that the x86 processor does not allow
  • both operands be memory locations.
  • mov [var1],[var2]

Instruction arguments

move instructions

MOV – move data

mov r/m8,reg8(copies content of 8-bit register (source) to 8-bit register or 8-bit memory unit (destination) )

mov reg32,imm32(copies content of 32-bit immediate (constant) to 32-bit register)

- In all forms of the MOV instruction, the two operands are the same size

Examples:mov EAX, 0x2334AAFFmov [buffer], ax

Note: 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.

Move instructions:

basic arithmetical instructions

ADD: add integers

add r/m16,imm16 (adds its two operands together, and leaves the result in its destination (first) operand)

Examples:add AX, BX

Basic arithmetical instructions:

ADC: add with carry

adc r/m16,imm8(adds its two operands together, plus the value of the carry flag, and leaves the result in its destination (first) operand)

Examples:add AX, BX (AX gets a value of AX+BX+CF)

basic arithmetical instructions cont

SUB: subtract integers

sub reg16,r/m16 (subtracts its second operand from its first, and leaves the result in its destination (first) operand)

Examples:sub AX, BX

Basic arithmetical instructions (Cont.):

SBB: subtract with borrow

sbb r/m16,imm8 (subtracts its second operand, plus the value of the carry flag, from its first, and leaves the result in its destination (first) operand)

Examples:sbb AX, BX (AX gets a value of AX-BX-CF)

basic arithmetical instructions cont1

INC: increment integer

inc r/m16 (adds 1 to its operand)

* doesnot affect the carry flag; affects all the other flags according to the result

Examples:inc AX

Basic arithmetical instructions (Cont.):

DEC: decrement integer

dec reg16 (subtracts 1 from its operand)

* doesnot affect the carry flag; affects all the other flags according to the result

Examples:dec byte [buffer]

basic logical instructions

NEG, NOT: two's and one's complement

neg r/m16 (replaces the contents of its operand by the two's complement negation - invert all the bits, and then add one)

not r/m16(performs one's complementnegation- inverts all the bits)

Examples:neg AL (if AL = (11111110), it becomes (00000010))

not AL (if AL = (11111110), it becomes (00000001))

Basic logical instructions:

basic logical instructions cont

OR: bitwise or

or r/m32,imm32 (each bit of the result is 1 if and only if at least one of the corresponding bits of the two inputs was 1; stores the result in the destination (first) operand)

Example:or AL, BL (if AL = (11111100), BL= (00000010) => AL would be (11111110))

Basic logical instructions (Cont.):

AND: bitwise and

and r/m32,imm32 (each bit of the result is 1 if and only if the corresponding bits of the two inputs were both 1; stores the result in the destination (first) operand)

Example:and AL, BL (if AL = (11111100), BL= (11000010) => AL would be (11000000))

compare instruction

CMP: compare integers

cmp r/m32,imm8 (performs a ‘mental’ subtraction of its second operand from its first operand, and affects the flags as if the subtraction had taken place, but does not store the result of the subtraction anywhere)

Example:cmp AL, BL (if AL = (11111100), BL= (00000010) => ZF would be 0) (if AL = (11111100), BL= (11111100) => ZF would be 1)

Compare instruction:

labels definition basic

Each instruction of the code has its offset (address from the beginning of the address space).

If we want to refer to the specific instruction in the code, we should mark it with a label:

my_instruction: add ax, ax…

- label can be with or without colon- an instruction that follows it can be at the same or the next line- a code can’t contain two different non-local (as above) labels with the same name

Labels definition (basic):

unconditional jump

JMP: jump to instruction

Usually it takes the form:

jmp label *see section B.4.130 JMP in the nasm manual for full specification

Tells the processor that the next

instruction to be executed is located at the label that is given as part of the instruction.


mov eax,1

inc_again: ; In this case it is infinite loop!

inc eax

jmp inc_again

mov ebx,eax ; Never reached from this code

Unconditional Jump:


Conditional Jumps:

JE,JG, JL, JGE, JLE, JNE: jump to instruction if condition is satisfied

Usually it takes the form:

j<cond> label*see section B.4.128 JMP in the nasm manual for full specification

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 dl,0

. . .

(code for reading a character into AL)

. . .

cmp al, ‘a’ ; compare the character to ‘a’

je a_received ; if equal, jump to a_received

inc cl ; otherwise, increment CL and

jmp read_char ;go back to read another


db dw dd declaring initialized data
DB, DW, DD : declaring initialized data

DB, DW, DD, DQ (DT, DDQ, and DO) are used to declareinitialized data in the output file. They can be invoked in a wide range of ways:

db 0x55 ; just the byte 0x55

db 0x55,0x56,0x57 ; three bytes in succession

db 'a',0x55 ; character constants are OK

db 'hello',13,10,'$‘ ; so are string constants

dw 0x1234 ; 0x34 0x12

dw 'a' ; 0x41 0x00 (it's just a number)

dw 'ab‘ ; 0x41 0x42 (character constant)

dw 'abc' ; 0x41 0x42 0x43 0x00 (string)

dd 0x12345678 ; 0x78 0x56 0x34 0x12 (dword)

assignment 0
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:

1. Convert lower case to upper case.

2. Convert ‘(’ into ‘<’.

3. Convert ‘)’ into ‘>’.

4. Count the number of the non-letter characters.

(Note: characters that are not letters,’(‘ or ‘)’ will remain as they are)

e.g. “42: heLL() WorLd!" → “42: HELL<> WORLD!“

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

The characters conversion should be in-place.

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


; 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 dword ebp


running nasm

To assemble a file, you issue a command of the form

> nasm -f <format> <filename> [-o <output>] [ -l listing]


> nasm -f elf mytry.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