Инструкции: Јазикот на

компјутерите
Поглавје 2
 Вовед

• Инструкции – зборовите во компјутерскиот

јазик

• Инструкциско множество – компјутерскиот

речник (сите валидни зборови)

• Ќе го обработиме инструкциското
множество развиено од MIPS Technologies
Пазари на MIPS
 Основни операции
• Секој компјутер мора да може да извршува
аритметички операции
• Секоја MIPS аритметичка инструкција
извршува една операција врз точно две
променливи
• Пример (со нотација од MIPS асемблерскиот
јазик)
add a, b, c #sumata od b i c stavi ja vo a

• Прв принцип на дизајн

ЕДНОСТАВНОСТА ЈА САКА РЕГУЛАРНОСТА
 Основни операции
C израз MIPS код
f=(g+h)–(i+j); add t0, g, h
add t1, i, j
sub f, t0, t1
 Операнди
• Операндите во аритметичките инструкции се
земаат од специјални хардверски локации
наречени регистри
• Големината на регистар во МИПС архитектура
е 32 бита
• Групи од 32 бита се толку чести, па им се дава
името збор
• Бројот на регистри е ограничен на 32, бидејќи:
– Многу голем број регистри можат да го зголемат
периодот на тактот
– Ограничување наметнато од инструкцискиот формат
 Операнди
• Со малиот број на регистри се запазува и
Вториот принцип на дизајн

ПОМАЛОТО Е ПОБРЗО
• MIPS конвенција за претставување на
регистрите
$s0, $s1, …
$t0, $t1, … - привремени регистри
$0, $1 , $2 ... , $31
• Пример
add $t0, $s1, $s2
 Операнди
Име Пример Коментар
32 регистри $s0–$s7, $t0– Брзи локации за податоците. Во МИПС
$t9,$zero, $a0– податоците мора секогаш да
$a3, $v0–$v1, бидат сместени во регистри, за да
$gp, $fp, може врз нив да се изврши одредена
$sp,$ra, $at операција, регистарот $zero секогаш
е еднаков на нула, и регистарот
$at е резервиран од асемблерот за
соочување со големи константи.

230 Memory[0], Достапни само преку инструкции за

мемориски Memory[4], . . . , пренос на податоци. МИПС користи
зборови Memory[4294967292] byte адреси, па секвенцијалните збор
адреси се разликуваат за 4.
Меморијата чува структури на
податоци, низи и регистри.
 Мемориски операции
• Процесорот може да чува мало количество податоци во
регистрите
• Затоа постојат инструкции за трансфер на податоци од и
кон меморијата – lw и sw
• За да пристапи до одреден збор, инструкцијата мора да
ја знае адресата на зборот
• Зборовите се сместени на адреси што се деливи со 4 –
порамнување
• Регистрите се побрзи и со поголема пропусна моќ од
меморијата
– Затоа компајлерот се труди најпотребните променливи да ги
смести во регистрите. Останатите ги префрла во меморијата
 Ендијанство
Регистер Регистер

Меморија Меморија

Голем Мал
ендијанец ендијанец

MIPS е голем ендијанец

 Мемориски операции
• Пример: Како ќе гласи MIPS кодот за C
доделувањето?
A[12] = h + A[8];
• Нека
– во $s2 е вредноста на h
– Во $s3 е почетната адреса на низата A[]

• Одговор:

lw $t0,32($s3) #vo t0 se skladira A[8]

add $t0,$s2,$t0
sw $t0,48($s3) #vo A[12] se skladira t0
 Непосредни операнди (константи)
• Тестовите за мерење на перформансите
покажале дека во повеќе од половина од
аритметичките операции еден од операндите
е константа
• Чување на константите во меморија бара
дополнителна lw инструкција
• Затоа постои quick add инструкција
addi $s1, $s3, 4 # $s1=$s3+4

• Трет принцип на дизајн

ЧЕСТИТЕ СЛУЧАИ НАПРАВИ ГИ ДА БИДАТ БРЗИ
 Репрезентација на броеви
• Броевите во компјутерскиот хардвер се третираат
како низа од високи и ниски електрични сигнали

• Погодно е овие сигнали да се разгледуваат како

бинарни броеви (со основа 2)

• MIPS зборовите се со должина 32 бити

– Со 32 бити можете да ги претставите сите броеви од 0
до 232-1

• Може да се случи резултатот од собирањето на два

броја да не може да се запише во 32 бита
– Велиме дека настанало пречекорување (overflow)
 Броеви со знак
• Негативните броеви се претставуваат со т.н. два
комплемент конвенција
• 0000 0000 0000 0000 0000 0000 0000 1010 два = 10 десет
• 1111 1111 1111 1111 1111 1111 1111 0110 два = -10 десет
• 1000 0000 0000 0000 0000 0000 0000 0010 два = -2 147 483 646 десет

• Предности на два комплементот

1. Брз начин да се добие негативниот број (инвертирај и
додади еден)
2. Едностанвна конверзија од 16-битен број во 32-битен
број (со вредноста на најзначајниот бит се пополнуваат
празните битски локации)
 Претставување на инструкциите
add $t0, $s1, $s2

0 17 18 8 0 32
$s1 $s2 $t0 машински
јазик
000000 10001 10010 01000 00000 100000

$s0 се мапира во 16-от регистер $t0 се мапира во 8-от регистер

$s1 се мапира во 17-от регистер $t1 се мапира во 9-от регистер
......................................................... ............................................................
$s7 се мапира во 23-от регистер $t7 се мапира во 15-тиот регистер
 R-формат на инструкција
op rs rt rd shamt funct
6 бита 5 бита 5 бита 5 бита 5 бита 6 бита

• op – операција и формат на инструкцијата

• rs – првиот регистар-операнд
• rt – вториот регистар-операнд
• rd – регистарот дестинација каде се
сместува резултатот
• shamt – поместување (shift)
• funct – функција (деф. варијантата на op )
 Типови на инструкции
• Четврт принцип на дизајн
Добар дизајн бара добри компромиси

• Идеално сакаме:
– сите инструкции да бидат со една должина
– да постои само еден инструкциски формат

• Проблем: Користење на R-формат на инструкција за

трансфер на зборови би ги ограничила низите (int
A[];) на најмногу 32 збора

• Компромис: Сите инструкции се со иста должина,

но постојат повеќе инструкциски формати за
различни инструкции . (I-формат на инструкции за
трансфер на зборови)
 Типови на инструкции
R-тип

I-тип
 Големата слика
• Денешните компјутери се базираат на два
фундаментални принципи:
1. Инструкциите може да се претстават како броеви
2. Програмите, како и броевите, може да се читаат
од и запишуваат во меморија
• Овие принципи доведоа до концептот
програми зачувани во меморија
• Уште повеќе, програмите се испорачуваат како
готови датотеки од бинарни броеви
• Компјутерите може да го користат готовиот
софтвер само ако се компатибилни со
инструкциското множество
• Затоа во индустријата егзистираат само мал
број на архитектури
 Логички операции

• Компјутерите работат со цели зборови

• Понекогаш е корисно да работат со бити
• Операциите кои тоа го овозможуваат се
познати како логички операции
 Поместување (shift)
• Содржината на регистерот $s0
0000 0000 0000 0000 0000 0000 0000 1001
• да се помести за 4 и да се смести во $t2
0000 0000 0000 0000 0000 0000 1001 0000
• МИПС инструкцијата е
sll $t2,$s0,4
• или преведено на машински јазик
 Поместување (shift)

• Поместување на број во лево за i места е

исто што и множење на бројот со 2i
 И (AND)
• AND користиме за да откриеме дали 12-от
бит од десно во регистерот $t1 е 1
0000 0000 0000 0000 1101 1100 0000 0000
• За таа цел користиме помошен број
(сместен во $t2) наречен маска
0000 0000 0000 0000 0000 1000 0000 0000
• МИПС инструкцијата за оваа операција е
and $t0,$t1,$t2
• ако $t0>0, 12-от бит од лево е 1
 ИЛИ (OR)
• OR користиме за да вметнеме 1 во 7-от бит од десно
во регистерот $t1
0000 0000 0000 0000 1101 1100 0000 0000
• За таа цел користиме помошен број сместен во $t2
0000 0000 0000 0000 0000 0000 0100 0000
• МИПС инструкцијата за оваа операција е
or $t0,$t1,$t2

• Резултатот во $t0 е

0000 0000 0000 0000 1101 1100 0100 0000

 НЕГАЦИЈА (NOT)

• NOT врши бит-по-бит инверзија

• Во MIPS е имплементирана NOR (NOT OR)

• NOT се добива кога едниот операнд во NOR

е нула
nor $t0,$t1,$zero
 Донесување одлуки (IF)

• Постојат две инструкции, традиционално

наречени условни гранења
beq регистар1, регистар2, лабела1
bne регистар1, регистар2, лабела1

beq - branch if equal

bne - branch if not equal
 Донесување одлуки (IF)
C израз MIPS код
if (i == j) bne $s3,$s4,Else
f = g + h; add $s0,$s1,$s2
j Exit

else Else:
f = g – h; sub $s0,$s1,$s2
Exit:
 Јамки (while, for, repeat,…)
C израз MIPS код
Loop: sll $t1,$s3,2 # $t1= i*4

add $t1,$t1,$s6 # $t1= &save[i]

while
(save[i]==k) lw $t0,0($t1) # $t0 = save[i]

i+=1;
bne $t0,$s5, Exit

Вредноста на i е во $s3 addi $s3,$s3,1

Вредноста на к е во $s5
Адресата на save е во $s6
j Loop

Exit:
 Инструкции за споредување

• Корисно е да постојат инструкции за

споредување на два броја > <
• MIPS асемблерскиот јазик ни нуди
slt $t0, $s3, $s4 # $t0=1 ако $s3<$s4

slti $t0, $s2, 10 # $t0=1, ако $s2<10

sltu $t0, $s3, $s4 # споредба без знак

 Инструкции за споредување
• $s0 ← 1111 1111 1111 1111 1111 1111 1111 1111два
• $s1 ← 0000 0000 0000 0000 0000 0000 0000 0001 два

• Кои се вредностите на регистрите $t0 и $t1

slt $t0, $s0, $s1 # со знак $t0=1

sltu $t1, $s0, $s1 # без знак $t1=0

 Case/switch
• Програмските јазиции вклучуваат наредба
како switch од програмскиот јазик C
• Оваа наредба може да се имплементира како
низа од if-then-else наредби
• Поедноставно е да се користи табела на
скокови (jump table) – низа од адреси на
лабели од кодот
• Од табелата се вчитува во регистер потребната
адреса
• Потоа со jr (jump register) инструкцијата
безусловно се скока до соодветната локација
 Поддршка за процедури во
хардверот
• Процедура е складирана подрутина што извршува
одредена задача заснована врз внесените параметри

• При изведувањето на процедурата, програмата мора да

следи шест чекори:
1. Сместување на параметрите таму каде што процедурата
може да им пристапи.
2. Префрлање на контролата на процедурата
3. Доделување ресурси за складирање, потребни за
процедурата
4. Извршување на посакуваната задача
5. Сместување на вредноста на резултатот таму каде што
повикувачката програма може да и пристапи
6. Враќање на контролата кон точката на повикување, зашто
процедурата може да биде повикана од повеќе точки во
програмата.
Регистри за работа со процедури
 Повик на процедура
jal Адреса_на_процедурата

• Jump-and-link прави две работи

1. Во регистерот $ra ја запишува адресата од
каде што била повикана процедурата
2. Скока до адресата од каде почнува
процедурата

• Од процедурата се враќаме до
повикувачкото место со jump register
jr $ra
 Повик на процедура
• Program Counter (PC) е регистер каде се
чува адресата на инструкцијата што
моментално се извршува

• Инструкцијата jal во регистерот $ra ја

запишува адресата на следната инструкција
PC+4
 Повик на процедура (резиме)
• Повикувачот става вредности во $a0-$a3
и ја користи jal X за да скокне до X

• Се извршува процедурата X

• Повиканата процедура X ги става

резултатите во $v0 и $v1 и ја враќа
контролата на повикувачот со jr $ra
 Користење на повеќе регистри
• Доколку компајлерот има потреба да
користи повеќе регистри, мора најпрвин да
ги зачува на сигурно место.

• Откако ќе заврши употребата на регистрите,

мора да бидат вратени вредностите
затекнати пред повикот на процедурата

• Податочната структура во која се прелеваат

(чуваат) регистрите се вика стек (stack)
 Користење на повеќе регистри
• Стек е редица од зборови која функционира
по правилото последен-влегол-прв-излегол
• На секој стек му е потребен стек покажувач
кој ќе покажува кон последната адреса
– Во MIPS тоа е $sp или $29
• Складирањето податоци во стекот е
познато како PUSH (притисни)
• Вадењето податоци е познато како POP
(скокни)
 Користење на повеќе регистри
• Во MIPS светот стекот расте од повисоките
адреси кон пониските
• Пример: (а) пред, (б) во текот, и (c) после
извршувањето на процедурата
 Користење на стек
• Пример:
addi $sp, $sp, –12 # направи место за 3 збора
sw $t1, 8($sp)
sw $t0, 4($sp)
sw $s0, 0($sp)

# се извршува некој код ...

lw $s0, 0($sp) # врати го регистарот $s0

lw $t0, 4($sp) # врати го регистарот $t0
lw $t1, 8($sp) # врати го регистарот $t1
addi $sp,$sp,12

jr $ra # скокни назад од кај си повикан

 Вгнездени процедури
• Некои процедури може да повикаат други
процедури, па дури и клонови на самите себе

• Се јавува конфликт околу користењето на

регистрите

• Можно решение
– Повикувачката процедура се грижи за регистрите
$a0-$a3 и $t0-$t9. Доколку и се потребни ги прелева
во стекот
– Повиканата процедура се грижи за регистрите
$s0-$s7 и $ra
 Вгнездени процедури
fact:
addi $sp, $sp, –8
Зачувај $ra и
sw $ra, 4($sp) $a0 на стек
sw $a0, 0($sp) Дали n<1,
int fact(int n) slti $t0,$a0,1 Ако n≥1, оди на
{ beq $t0,$zero,L1 L1
if (n<1) addi $v0,$zero,1 Ако n<1 врати
return (1); addi $sp,$sp,8 1 ($v0), врати
else jr $ra од стек и назад
return (n*fact(n–1)); L1: addi $a0,$a0,–1 n=n-1 ($a0),
} jal fact повик fact
lw $a0, 0($sp)
Враќање од jal,
lw $ra, 4($sp) празни стек
addi $sp, $sp, 8
mul $v0,$a0,$v0 n*fact (n – 1)
jr $ra ($v0) и назад
 Глобален покажувач
• Променливите во програмскиот јазик C
имаат тип (int, double,…) и магацинска
класа (automatic и static)
• Automatic променливите се локални за
процедурата и се уништуваат кога таа
завршува
• Static променливите се дефинираат надвор
од сите процедури и постојат независно од
нив
• За пристап до статичките променливи во
MIPS се користи глобален покажувач $gp
 Алокација на големи податоци
• Стекот се користи и за чување на големи податочни
објекти (низи и структури) што се локални за
процедурата

• Активациски запис или рамка на процедурата е

сегментот каде се чуваат овие податоци заедно со
снимените регистри

• Некои MIPS компајлери имплементираат покажувач

кон рамка $fp да покажува кон првиот збор од
рамката на процедурата

• Со $fp се олеснува пристапот кон рамката, иако

истото може да се изведе и со $sp и мала
аритметика
Сместување на големи податоци
Сместување на податоци во Heap-от

текстуален сегмент Сегмент од (UNIX)

објектна датотека која содржи код во
машински јазик за рутини во изворната
датотека.
 Сместување на повеќе од 4 влезни
параметри
• Доколку процедурата очекува повеќе од 4
влезни параметри, MIPS конвенција е тие
да бидат сместени веднаш над $fp
поинтерот
 Материјал за учење

• Овој час ги покрива лекциите 2.1-2.8 од

книгата на Патерсон Хенеси

• Следниот час 2.9 - ...