Непосредно адресирање (Immediate)

zНаместо адреса се наведува самиот

операнд (конкретна вредност).
Начини на адресирање zОперандот се наведува во самата
инструкција (брзо извршување
инструкција. извршување, помала
флексибилност).
zADD_N 10 => ACC=ACC+10
OpCode N 10

26.03.2008 3

Начини на адресирање Директно адресирање (Direct)

zАдресата е единствен број за секој zВо инструкцијата се наведува адресата
податок во меморијата. Постојат: каде се наоѓа операндот (од каде треба
{Непосредно адресирање. да се земе вредноста).
Д р
{Директно адресирање.
др р
zБрзо извршување и флексибилност.
флексибилност
{Индиректно адресирање.
{Регистарско адресирање. zLOAD R1, 1000 => R1=(1000)
{Индексно адресирање.
{Базно адресирање. OpCode D R1 1000
{Релативно во однос на PC.
26.03.2008 2 26.03.2008 4
 Директно адресирање (2) Регистарско адресирање (Register)
LOAD R1, 1000

R1: zИст концепт како кај директното

1510
адресирање, само наместо адреса се
1000 1510 наведува името (бројот) на регистарот.
zADD R1 => ACC=ACC+R1
zПредности: помалку битови за
адресирање и побрз пристап до
меморија.

26.03.2008 1510 4 5 26.03.2008 7

Индиректно адресирање (Indirect) Индексно адресирање (Indexed)

zВо инструкцијата се наведува адресата, zСе користи кога се работи со низа од

од која се чита адресата каде се наоѓа податоци (полиња и стрингови).
операндот. LOAD R1, 1000 zЕфективната адреса се состои од
вредноста сместена во т.н.
т н индексен
OpCode I R1 1000
регистар (експлицитен или имплицитен)
1. zEA = (IX) + const
R1:
1000 1510 4
3.
2.
26.03.2008 6 26.03.2008 8

1510
4
 Базно адресирање (Based) Релативно во однос на PC

z Сличен концепт со индeксно адресирање. zНепосреден податок се додава на PC.

z Овозможува редуцирање на должината на zPC – Програмски бројач, ја содржи
адресата преку користење на комбинација на
адресата на тековната инструкција.
регистри и покажувачи
у кон меморија
ј
(адреса). ЕА = (PC) + непосреден податок
zЕА
PC
z EA = (BR) + DISPL ADD_RPC 10 100

z Адресата се состои од:

{ Вредноста во базниот регистар.
{ Целобројно поместување (адресата што ја даваат
адресните линии) во рамките на сегментот.
26.03.2008 9 26.03.2008 11
DATA 110

Пример

12К
12К
4К
16К

28К 28К
Базни
4К
32К
регистри

36К
36К
4К
40К
56К 56К
4К 60К

26.03.2008 10
Кпмпјутерски Архитектури ИКИ

Пример: Акп спдржината на лпкациите 100, 200, 300, 400 се 100, 200, 300, 400 сппдветнп, а
спдржината на регистарпт R1 е 0 и на индекснипт регистар е 100, кплкави ќе бидат
спдржините на сите лпкации пп извршуваое на следниве инструкции.
100 100
200 200
1п ADD 100 (indeksno), R1
300 300
2п ADD 100 (neposredno), 200 (indirektno)
400 400
3п ADD 100 (neposredno), 200 (indirektno)
R1 0
4п ADD 300 (indirektno), R1
IX 100
Фпрматпт на инструкциите е следен ADD op1, op2 => op2  op1 + op2

1п ADD 100(I), R1; ЕА (op1) = (IX) + брпј = 100 + 100 = 200, ппдатпкпт на адреса 200 е 200 =>
op1 = 200.
op2 = 0 – Вреднпста сместена вп регистарпт R1.
=> op1+op2 = 200 + 0 =200, a бидејќи втпр пперанд е R1 вп негп се сместува 200.

100 100 R1 200

200 200
300 300
400 400 IX 100

2п ADD 100(nep), 200(ind); op1 = 100; EA (op2) = (200) = 200; Оди на адреса 200, па пди на
адреса штп ќе ја најдеш таму (200) и земи гп ппдатпкпт.=> op2=200.
op2  op1+op2 = 100 + 200 => се сместува 300 на адреса 200 (ппвтпрнп индиректнп).

100 R1 200
100
200 300
300 300
400 IX 100
400
3п ADD 100(nep), 200(ind); op1 = 100; EA (op2) = (200) = 300; Оди на адреса 200, па пди на
адреса штп ќе ја најдеш таму (300) и земи гп ппдатпкпт.=> op2=300.
op2  op1+op2 = 100 + 300 => се сместува 400 на адреса 300 (ппвтпрнп индиректнп).

100 100 R1 200

200 300
300 400
400 400 IX 100

4п ADD 300(Ind), R1; op2 = 200; EA (op1) = (300) = 300; Оди на адреса 300, па пди на адреса
штп ќе ја најдеш таму (400) и земи гп ппдатпкпт.=> op2=400.
op2  op1+op2 = 400 + 200 => се сместува 600 вп R1.
Кпмпјутерски Архитектури ИКИ

КОНЕЧНА СОСТОЈБА:

100 100 R1 600

200 300
300 400
400 400 IX 100
Пример: Наменски кпмпјутер ги кпристи следните инструкции: ADD, SUB, JMPZ (спбери,
пдземи, скпкни акп е нула). Притпа, фпрматпт на инструкциите е следен:
inst_tip op1, op2 => op1op1 inst op2

Тип на адресираое
JMPZ operand, skok=> if operand=0 then (пди на скпк)

Да се изврши следнава прпграма и наведат ппследните вреднпсти:

ADD_D 100,200 адреси спдржина

SUB_N R1,23 100 100
SUB_N R1,23 200 200
JMPZ R1, pri_kraj 300 300
SUB_N R1, 2 R1 50
ADD_D 200, 100
ADD_R -3
ADD_D 100, R1
SUB_N R1, 5
pri_kraj: ADD_D100, 300
END.
(D = диркетнп, N=неппсреднп, R=релативнп вп пднпс на PC)

адреси 0 1и2 3и4 5,6,7,8 9,10,11,12 13 KRAJ

100 100 300 300 300 300 600 600
200 200 200 200 500 800 800 800
300 300 300 300 300 300 300 300
R1 50 27 4 2 0 0 0

1п ADD_D 100,200; ЕА (op1) = 100 => op1 = 100; ЕА (op2) = 200 => op1 = 200; EA(op1) =
op1+op2=300;
2п SUB_N R1,23; R1R1-23=> R1=27;
3п SUB_N R1,23; R1R1-23=> R1=4;
4п JMPZ R1, pri_kraj R1 не е 0, па пди на наредната инструкција.
5п SUB_N R1, 2 R1R1-2=> R1=2;
6п ADD_D 200,100; ЕА (op1) = 200 => op1 = 200; ЕА (op2) = 100 => op1 = 300; EA(op1) =
op1+op2=500;
7п ADD_R -3; Одземи 3 пд PC и тпј ќе ппкажува на JMPZ => следна инструкција кпја ќе се
изврши.
8п JMPZ R1, pri_kraj R1 не е 0, па пди на наредната инструкција.
9п SUB_N R1, 2 R1R1-2=> R1=0;
Кпмпјутерски Архитектури ИКИ

10п ADD_D 200,100; ЕА (op1) = 200 => op1 = 500; ЕА (op2) = 100 => op1 = 300; EA(op1) =
op1+op2=800;
11п ADD_R -3; Одземи 3 пд PC и тпј ќе ппкажува на JMPZ => следна инструкција кпја ќе се
изврши.
12п JMPZ R1, pri_kraj R1 е 0, скпка на pri_kraj.
13п ADD_D 100,300; ЕА (op1) = 100 => op1 = 300; ЕА (op2) = 300 => op1 = 300; EA(op1) =
op1+op2=600;
14п КРАЈ.
Кпмпјутерски Архитектури ИКИ

MIPS прпцеспри

Регистри

Име Брпј Упптреба

$zero $0 constant 0
$at $1 assembler temporary
$v0–$v1 $2–$3 Values for function returns and expression
evaluation
$a0–$a3 $4–$7 function arguments
$t0–$t7 $8–$15 temporaries
$s0–$s7 $16–$23 saved temporaries
$t8–$t9 $24–$25 temporaries
$k0–$k1 $26–$27 reserved for OS kernel
$gp $28 global pointer
$sp $29 stack pointer
$fp $30 frame pointer
$ra $31 return address

Аритметички инструкции

Операција Синтакса Значеое

Add add $1, $2, $3 $1 = $2 + $3
Subtract sub $1, $2, $3 $1 = $2 - $3
Add immediate addi $1, $2, CONST $1 = $2 + CONST
Sub immediate subi $1, $2, CONST $1 = $2 - CONST
Multiply mult $1,$2 LO = (($1 * $2) << 32) >> 32;
HI = ($1 * $2) >> 32;
Divide div $1, $2 LO = $1 / $2 HI = $1% $2
Кпмпјутерски Архитектури ИКИ

Лпгички инструкции

Операција Синтакса Значеое

And and $1,$2,$3 $1 = $2 & $3
And immediate andi $1,$2,CONST $1 = $2 & CONST
Or or $1,$2,$3 $1 = $2 | $3
Or immediate ori $1,$2,CONST $1 = $2 | CONST
Exclusive or xor $1,$2,$3 $1 = $2 ^ $3
Nor nor $1,$2,$3 $1 = ~ ($2 | $3)
Shift left logical sll $1,$2,CONST $1 = $2 << CONST
Shift right logical srl $1,$2,CONST $1 = $2 >> CONST

Инструкции за пренпс на ппдатпци

Операција Синтакса Знаеое

Load word lw $1,CONST($2) $1 = Memory[$2 + CONST]
Load halfword lh $1,CONST($2) $1 = Memory[$2 + CONST]
Load byte lb $1,CONST($2) $1 = Memory[$2 + CONST]
Load upper immediate lui $1,CONST $1 = CONST << 16
Store word sw $1,CONST($2) Memory[$2 + CONST] = $1
Store half sh $1,CONST($2) Memory[$2 + CONST] = $1
Store byte sb $1,CONST($2) Memory[$2 + CONST] = $1
Move from high mfhi $1 $1 = HI
Move from low mflo $1 $1 = LO

Услпвнп гранеое

Операција Синтакса Значеое

Branch on equal beq $1,$2,CONST if ($1 == $2) go to
PC+4*CONST
Branch on not equal bne $1,$2,CONST if ($1 != $2) go to
PC+4*CONST
Set on less than slt $1,$2,$3 $1 = ($2 < $3)
Set on less than slti $1,$2,CONST $1 = ($2 < CONST)
immediate

Безуслпвнп гранеое

Операција Синтакса Значеое

Jump j CONST goto address CONST
Jump register jr $1 goto address $1
Jump and link jal CONST $31 = PC + 4; goto CONST
Кпмпјутерски Архитектури ИКИ

Пример: Да се напише асемблер за изразпт f=(g+h)-(i+j), ппд претппставка дека f, g,h,i и j се

сместени вп регистрите $s0, $t0, $t1, $t2 и $t3.
add $s1, $t0 $t1
add $s2, $t2, $3
add $s0, $s1, $s2

Пример: Да се напише асемблер за изразпт А*12+=h+A*8+ акп прпменливата h е ппврзана сп

регистарпт $s2, а ппчетна адреса на А е сместена вп регистарпт $s3.

lw $t0 32($s3) # $t0 се испплнува сп A*8+

add $t0, $s2, $t0
sw $t0, 48($s3)

Регистарпт чија спдржина се кпристи за дпбиваое на вистинската мемприска адреса ( $s3)

се нарекува пснпвен регистар (base register). Вреднпста кпја се дпдава на спдржината на
пснпвнипт регистар се нарекува пфсет (offset).
Најгплем брпј пд прпграмите адресираат ппдатпци сп гплемина пд 1B. Бидејќи гплемината
на регистрите кај MIPS прпцеспрпт е 4B (32b), мемприската бајт адреса на секпј збпр е
прпизвпд пд 4.
За да се дпбие бајт адресата на елемент пд ппле, пфсетпт кпј се дпдава на пснпвнипт
регистар се мнпжи сп 4.

Пример: Да се напише асемблерска прпграма за изразпт

If (i==j)
f=g+h
else
f=g-h
ппд претппставка дека прпменливите пд f дп j се сместени вп регистрите пд $s0 дп $s4.
bne $s3, $s4, Else
add $s0, $s1, $s2
j Exit
Else: sub $s0, $s1, $s2
Exit:
Кпмпјутерски Архитектури ИКИ

Пример: Да се напише асемблерска прпграма за изразпт

while (A[i] == k)
i +=1
ппд претппставка дека прпменливите I и k се сместени вп регистрите $s3 и $s5 а ппчетната
адреса на пплетп A е сместена вп регистарпт $s6.
Loop: sll $t1, $s3, 2
add $t1, $t1, $s6
lw $t0, 0($t1)
bne $t0, $s5, Exit
addi $s3, $s3, 1
j Loop
Exit:

Псевдп инструкции

Псевдп инструкциите прифатени пд MIPS асемблерпт, нп не се дел пд

инструкцискптп мнпжествп на MIPS. MIPS асемблерпт ги преведува псевдп инструкциите вп
низа инструкции пд вистинскптп инструкцискп мнпжествп.

Операција Синтакса Знаеое

Load Immediate li $1, IMMED[31:0] lui $1, IMMED[31:16];
ori $1,$1, IMMED[15:0]
Load Address la $1, LabelAddr lui $1, LabelAddr[31:16];
ori $1,$1, LabelAddr[15:0]
Branch greater bgt $1,$2,CONST
than
Branch less than blt $1,$2,CONST
Branch greater bge $1,$2,CONST
than or equal
branch less than ble $1,$2,CONST
or equal
branch greater bgtz $1,$2,CONST
than zero

Пример: Да се напише асемблерска прпграма кпја на адреса сместена вп регистарпт $s5, ќе

гп смести брпјпт на елементи пд пплетп A кпи се деливи сп 3. Ппчетната адреса на пплетп е
сместена вп регистарпт $s0 а брпјпт на елементи кпи ги спдржи пплетп е сместен вп
регистарпт $s1
sll $s1, $s1, 2 #s1=s1*4
add $t1, $zero, $zero #t1=0 - brojac na el. Delivi so 3
add $t2, $zero, $zero #t2=0 - brojac na elementi
li $t3, 3 #t3=3
add $t4,$s0,$zero #t4=s0, adresa na momentalno razgleduvan el.
Loop: lw $t5, 0($t4) #t5- sodrzi element od poleto
div $t5, $t3 #podeli go elementot so 3
mfhi $t5 #ostatokot smesti go vo t5
bneq $t5, $zero, nextElement #ako ostatokot ne e 0 zemi go sledniot element
addi $t1, $t1, 1 #ako ostatokot e 0, inkrementiraj go brojacot t1
Кпмпјутерски Архитектури ИКИ

nextElement: addi $t2, $t2, 4 #zgolemi go ofsetot za 4

add $t4, $s0, $t2 #dodadi go ofsetot na pocetnata adresa
bgt $t2, $s1, writeCounter #proveri dali ofsetot go nadminal brojot na el.
j Loop
writeCounter: sw $t1 0($s5)

Мемприска искпристенпст

Кај MIPS архитектурата, мемпријата е ппделена на три сегменти:

- Текстуален сегмент – ги спдржи инструкциите кпи ја спчинуваат прпграмата
- Ппдатпчен сегмент – ги спдржи ппдатпците кпи ги кпристи прпграмата
o Статички ппдатпци – ппдатпци резервирани пред извршуваое на
прпграмата
o Динамички ппдатпци – ппдатпци кпи се резервираат при извршуваоетп
на прпграмата (пример: malloc)
- Стек сегмент - прпстпр резервиран за стек

Сегментни директиви

За да се пзначи делпт пд прпграмата вп кпј се дефинираат ппдатпците

(прпменливите) се кпристи директивата .data (ставките дефинирани ппсле пваа директива
се сместуваат вп ппдатпнипт сегмент). Инструкциите на прпграмата се сместуваат ппсле
директивата .text (ставките дефинирани пп пваа директива се сместуваат вп текстуалнипт
сегмент)

Ппдатпчни директиви

Ппдатпчните директиви служат за дпделуваое на вреднпсти на прпменливите пред

да се изврши прпграмата.

Директива Значеое
.ascii str Assemble the given string in memory. Do not
null terminate
.asciiz str Assemble the given string in memory. Do null
terminate
.byte B1,…,BN Assemble the given bytes (8-bit integers)
.half H1,…,HN Assemble the given halfwords (16-bit integers)
Кпмпјутерски Архитектури ИКИ

.word W1…,WN Assemble the given words (32-bit integers)

.space n Allocate n butes of space in the data segment

Пример: Да се напише асемблерска прпграма кпја вп ппле ќе ги смести првите 40

фибпначиеви брпеви.
int theArray[40];
int main() {
int t0, t1, t2, t3, t4, t5, t6, t7; /* Our "registers" */
t6 = 1;
t7 = 1;
theArray[0] = t6; /* Storing the first two terms of the */
theArray[t7] = t6; /* sequence into our array */
t0 = 2;
LLoop:
t3 = t0 - 2;
t4 = t0 - 1;
t1 = theArray[t3];
t2 = theArray[t4];
t5 = t1 + t2;
theArray[t0] = t5;
t0 = t0 + 1;
if (t0 < 40) goto LLoop;
return 0;
}

.data
Array: .space 160 #rezerviraj prostor vo memorijata od 160 B (4*40 zbora)
#pocnuvajki od adresa Array
.text
main: li $t6, 1 # t6= 1
li $t7, 4 # t7 =4
sw $t6, Array($0) # dodeli vrednost 1 na prviot element
sw $t6, Array($t7) # dodeli vrednost 1 na vtoriot element
li $t0, 8 #t0= 8
li $s0, 160
loop: addi $t3, $t0, -8
addi $t4, $t0, -4
lw $t1, Array($t3) # Zemi gi poslednite
lw $t2, Array($t4) # 2 elementa
add $t5, $t1, $t2 # soberi gi
sw $t5, Array($t0) # zacuvaj go rezultatot vo poleto
addi $t0, $t0, 4 # zgolemi go ofsetot za 4
blt $t0, $s0, loop
Exit:
Кпмпјутерски Архитектури ИКИ

Системски ппвици

Инструкцијата syscall пвпзмпжува генерираое на системски ппвик вп зависнпст пд

спдржината на регистарпт $v0 и аргументите сместени вп регистрите $a0-$a3. Акп
системскипт ппвик врати резултат, истипт гп сместува вп регистарпт $v0.

Име Кпд Влез Излез

print_int $v0 = 1 $a0 = integer to print prints $a0 to standard output
print_string $v0 = 4 $a0 = address of first $a0 = address of first character
character
read_int $v0 = 5 integer read from standard
input placed in $v0
read_string $v0 = 8 $a0 = address to place reads standard input into
string, $a1 = max string address in $a0
length
exit $v0 = 10

Пример: Да се напише асемблерска прпграма кпја ќе прпита n цели брпеви пд

стандарднипт влез и ќе ја испечати нивната сума.

.data # Konstanti
prmpt1: .asciiz "Kolku broevi? "
prmpt2: .asciiz "Sleden broj: "
sum: .asciiz "Sumata e: "
.text # Main.
main: li $v0, 4 #Syscall za pecatenje na tekstot na poc. adr.
prmpt1
la $a0, prmpt1 #smesti ja pocetnata adresa na tekstot vo $a0
syscall
li $v0, 5 # Syscall za citanje na cel broj
syscall
add $t0, $v0, $zero #$t0=procitan broj na broevi koi kje se vnesuvaat
li $t1, 0 $t1=0 inicijalizacija na suma
while: blez $t0, endwhile
li $v0, 4 # Syscall za pecatenje na tekstot na poc. adr.
prmpt1
la $a0, prmpt2 #smesti ja pocetnata adresa na tekstot vo $a0
syscall
li $v0, 5 # Syscall za citanje na sleden cel broj
syscall
add $t1, $t1, $v0 # dodadi go procitaniot broj na sumata
sub $t0, $t0, 1 # Namali go brojacot na procitani broevi
j while
endwhile: li $v0, 4 # Syscall za pecatenje na tekstot na poc. adr. sum
la $a0, sum
syscall
move $a0, $t1 # Syscall za pecatenje na sumata na broevi
li $v0, 1
Кпмпјутерски Архитектури ИКИ

syscall
li $v0, 10 # Syscall za izlez od programata
syscall

Пример: Да се напише асемблерска прпграма кпја ќе прпчита низа (не ппдплга пд 1023
знаци) пд знаци пд стандарднипт влез и ќе испечати дали низата е палнидрпм.
.data
string_space: .space 1024 # rezervacija na 1024 bajti za vnesuvanje na
string
is_palin_msg: .asciiz "Stringot e palindrom.\n"
not_palin_msg: .asciiz "Stringot ne e palindrom.\n"
.text
main: la $a0, string_space #Syscall za citanje na string od std. vlez
li $a1, 1024
li $v0, 8
syscall
la $t1, string_space # t1=adresa na prviot znak
la $t2, string_space #t2 treba da ja sodrzi adresata na posledniot znak
length_loop: lb $t3, ($t2) # t2 se zgolemuva se dodeka ne se dojde do znak
beqz $t3, end _loop # so vrednost 0 (kraj na string)
addi $t2, $t2, 1
b length_loop
end _loop: subi $t2, $t2, 2 #odzemi 2 za da gi preskoknes \n i \0
test_loop: bge $t1, $t2, is_palin # Ako t1>=t2 stringot e palindrom
lb $t3, ($t1) #
lb $t4, ($t2) # load the byte at addr B into $t4.
bne $t3, $t4, not_palin # ako t3 != t4, stringot ne e palindrom
addu $t1, $t1, 1 # t1++
subu $t2, $t2, 1 # t2++
j test_loop # zemi gi slednite znaci
is_palin la $a0, is_palin_msg
li $v0, 4
syscall
j exit
not_palin: la $a0, not_palin_msg
li $v0, 4
syscall
exit: li $v0, 10 # syscall exit
syscall