NSTRUMENTA COMPUTATORIA WYBRANE ARCHITEKTURY...

Poniższy tekst był postawą książki o tym samym tytule opublikowanej przez Wydawnictwo Helion w 2000 r.

Witold Komorowski

INSTRUMENTA COMPUTATORIA

WYBRANE ARCHITEKTURY KOMPUTERÓW

W.Komorowski: Instrumenta computatoria 2

IBM 360-370 - RODZINA KOMPUTERÓW ............................................. 8

Historia ............................................................................................................................................... 8

Procesor centralny ............................................................................................................................. 9

Formaty danych ............................................................................................................................... 11

Kodowanie rozkazów ....................................................................................................................... 12

Lista rozkazów ................................................................................................................................. 15 Rozkazy działań arytmetycznych .................................................................................................................. 15 Rozkazy działań logicznych .......................................................................................................................... 17 Rozkazy przesunięć ....................................................................................................................................... 17 Rozkazy przesłań .......................................................................................................................................... 18 Rozkazy testowania ....................................................................................................................................... 19 Rozkazy konwersji ........................................................................................................................................ 19 Rozkazy działań na łańcuchach znaków ....................................................................................................... 20 Rozkazy skokowe ......................................................................................................................................... 20 Rozkazy systemowe ...................................................................................................................................... 21 Rozkazy wejścia-wyjścia .............................................................................................................................. 21

Przerwania........................................................................................................................................ 22

PDP-11 - MINIKOMPUTER 16-BITOWY .............................................. 24

Historia ............................................................................................................................................. 24

Procesor centralny ........................................................................................................................... 25


Lista rozkazów ................................................................................................................................. 29 Rozkazy przesłań .......................................................................................................................................... 29 Rozkazy arytmetyczne .................................................................................................................................. 30 Rozkazy logiczne .......................................................................................................................................... 31 Rozkazy sterujące ......................................................................................................................................... 31 Rozkazy systemowe ...................................................................................................................................... 32

Przerwania........................................................................................................................................ 33

VAX - SUPERMINIKOMPUTER ............................................................ 35

Historia ............................................................................................................................................. 35

Rejestry procesora ........................................................................................................................... 35

Słowo rozkazowe .............................................................................................................................. 36 Struktura rozkazu .......................................................................................................................................... 36 Adresowanie argumentów ............................................................................................................................. 37 Przykłady ...................................................................................................................................................... 38

Formaty danych ............................................................................................................................... 39

Lista rozkazów ................................................................................................................................. 40 Zmiany typu danych ...................................................................................................................................... 41 Przesłania ...................................................................................................................................................... 41 Działania arytmetyczne ................................................................................................................................. 42 Działania logiczne ......................................................................................................................................... 44 Przesunięcia .................................................................................................................................................. 44 Badanie warunków ........................................................................................................................................ 45 Działania na łańcuchach bajtów .................................................................................................................... 46 Działania na polach zmiennej długości ........................................................................................................ 47 Działania na kolejkach .................................................................................................................................. 48 Blokada dostępu do argumentów .................................................................................................................. 49 Rozkazy skokowe ......................................................................................................................................... 49 Rozkazy systemowe ...................................................................................................................................... 52


8051 - MIKROKOMPUTER JEDNOUKŁADOWY ................................... 55

Historia ............................................................................................................................................. 55


Pamięć ............................................................................................................................................... 56


Lista rozkazów ................................................................................................................................. 59 Rozkazy przesłań .......................................................................................................................................... 60 Rozkazy arytmetyczne .................................................................................................................................. 60 Rozkazy logiczne .......................................................................................................................................... 60 Procesor boolowski ....................................................................................................................................... 61 Rozkazy sterujące ......................................................................................................................................... 61

Przerwania........................................................................................................................................ 62

INTEL X86 - ARCHITEKTURA IA-16 I IA-32 ...................................... 64

Historia ............................................................................................................................................. 64

Dwie architektury ............................................................................................................................ 65

Rejestry ............................................................................................................................................. 66

Formaty rozkazów ........................................................................................................................... 68 Przedrostki .................................................................................................................................................... 68 Kod operacji .................................................................................................................................................. 68 Pole adresowe ............................................................................................................................................... 69 Pole przesunięcia ........................................................................................................................................... 73 Pole argumentu bezpośredniego.................................................................................................................... 73 Przykłady budowy słowa rozkazowego ........................................................................................................ 74

Formaty danych ............................................................................................................................... 74

System przerwań .............................................................................................................................. 77

Lista rozkazów ................................................................................................................................. 77 Przesłania ...................................................................................................................................................... 78 Konwersja formatu ........................................................................................................................................ 79 Komunikacja z portami we-wy ..................................................................................................................... 80 Manipulacje znacznikami ............................................................................................................................. 81 Działania na adresach .................................................................................................................................... 81 Działania arytmetyczne na liczbach całkowitych.......................................................................................... 82 Korekcja dziesiętna ....................................................................................................................................... 82 Porównania ................................................................................................................................................... 82 Działania logiczne ......................................................................................................................................... 83 Przesunięcia .................................................................................................................................................. 84 Działania na pojedynczych bitach ................................................................................................................. 85 Działania na łańcuchach ................................................................................................................................ 86 Rozkazy sterujące przebieg programu .......................................................................................................... 86 Skoki bezwarunkowe i wywołania procedur ................................................................................................. 87 Skoki warunkowe .......................................................................................................................................... 87 Rozkazy powrotu .......................................................................................................................................... 88 Warunkowe ustawianie bajta ........................................................................................................................ 88 Operacja pusta ............................................................................................................................................... 89 Rozkazy systemowe ...................................................................................................................................... 89 Działania na liczbach zmiennoprzecinkowych (FPU) .................................................................................. 89 Działania na danych upakowanych (MMX) ................................................................................................. 95


TRANSPUTER - ELEMENT SIECI PROCESORÓW ................................. 98

Historia ............................................................................................................................................. 98


Format rozkazu .............................................................................................................................. 100

Lista rozkazów ............................................................................................................................... 101 Podstawowa lista rozkazów ........................................................................................................................ 101 Rozkazy przesłań ........................................................................................................................................ 102 Rozkazy arytmetyczne ................................................................................................................................ 104 Rozkazy logiczne ........................................................................................................................................ 104 Rozkazy konwersji formatu ........................................................................................................................ 105 Rozkazy skoków ......................................................................................................................................... 106 Rozkazy obsługi błędów ............................................................................................................................. 107 Rozkazy obsługi kolejek ............................................................................................................................. 108 Rozkazy zarządzania procesami.................................................................................................................. 109 Rozkazy obsługi zegara............................................................................................................................... 110

SPARC - ARCHITEKTURA OTWARTA .............................................. 111

Historia ........................................................................................................................................... 111

Rejestry ........................................................................................................................................... 111 Rejestry ogólne. .......................................................................................................................................... 111 Rejestry specjalne. ...................................................................................................................................... 113

Formaty rozkazów ......................................................................................................................... 113

Adres efektywny ............................................................................................................................. 115

Lista rozkazów ............................................................................................................................... 115 Rozkazy komunikacji z pamięcią ................................................................................................................ 115 Rozkazy arytmetyczne ................................................................................................................................ 116 Rozkazy logiczne ........................................................................................................................................ 117 Rozkazy przesunięć ..................................................................................................................................... 118 Rozkazy sterujące program ......................................................................................................................... 118 Rozkaz sethi ................................................................................................................................................ 120 Rozkazy specjalne ....................................................................................................................................... 121 Rozkazy znakowane .................................................................................................................................... 121

Pseudorozkazy asemblera ............................................................................................................. 121

GHIBLI - MODEL PROSTEGO KOMPUTERA ...................................... 123

Architektura ................................................................................................................................... 123 Ogólna charakterystyka ............................................................................................................................... 123 Lista rozkazów ............................................................................................................................................ 125 Przerwania ................................................................................................................................................... 129

Formalny opis architektury Ghibli .............................................................................................. 130

Język asemblera ............................................................................................................................. 132 Sposoby adresacji ........................................................................................................................................ 132 Rozkazy....................................................................................................................................................... 133 Dyrektywy ................................................................................................................................................... 134 Składnia....................................................................................................................................................... 135 Przykłady programów ................................................................................................................................. 135

Struktura ........................................................................................................................................ 139 Pamięć główna ............................................................................................................................................ 140 Centralne sterowanie ................................................................................................................................... 140 Arytmometr ................................................................................................................................................. 141 Porty wejściowe i wyjściowe ...................................................................................................................... 142


JĘZYK OPISU ARCHITEKTURY ......................................................... 143

Podstawy ......................................................................................................................................... 143

Notacja ............................................................................................................................................ 143

Deklaracje i definicje ..................................................................................................................... 143

Zmiana stanu .................................................................................................................................. 144

Operacje.......................................................................................................................................... 145 Przesłania .................................................................................................................................................... 145 Relacje......................................................................................................................................................... 145 Operacje logiczne ........................................................................................................................................ 145 Operacje arytmetyczne ................................................................................................................................ 146 Operacje łańcuchowe .................................................................................................................................. 146

Inne symbole................................................................................................................................... 147

Stałe ................................................................................................................................................. 147 System liczenia ........................................................................................................................................... 147 Reprezentacja liczb ..................................................................................................................................... 147

ŹRÓDŁA ............................................................................................. 149

Książki ............................................................................................................................................ 149

Internet ........................................................................................................................................... 150


We współzawodnictwie między tym, co wartościowe, a tym, co nowe, bezwzględnie wygrywa nowe.

Ryszard Kapuściński

Tytuł tego zbioru, wzięty ze słownika współczesnej łaciny (Lexicon recentis Latinitatis, Citta del Vaticano, 1992-1997) a oznaczający po prostu komputery, sugeruje pewną „klasyczność” omawianej tematyki. Przedstawiane tu przykłady rzeczywiście można uznać za klasyczne a więc reprezentatywne dla rozwoju informatyki w ostatnich czterech dekadach. W tym czasie komputer, w różnych swych zastosowaniach, stał się nieusuwalnym elementem cywilizacji, a zmiany, już nie tylko techniczne ale i kulturowe, jakie wprowadził pozwalają obecnie mówić o „erze informatycznej”. Na tę zależność od narzędzia wskazuje amerykański termin computer science zastępujący przyjętą w Europie nazwę informatyka.

Każdy komputer można opisać na kilka sposobów; inny jest opis jego działania obserwowany przez użytkownika programu aplikacyjnego a inny, gdy obserwatorem jest programista systemowy. Z kolei dla konstruktora istotna będzie struktura logiczna bloków funkcjonalnych i rodzaj układów elektronicznych, z których komputer jest zbudowany. Najbardziej abstrakcyjny, ale jeszcze przydatny dla użytkownika opis sprzętu daje architektura komputera - termin wprowadzony w latach 60. a oznaczający zachowanie się komputera obserwowane na poziomie języka wewnętrznego (poziom ten jest np. dostępny przy programowaniu w asemblerze). W tym sensie atrybutami architektury są: lista rozkazów, sposoby kodowania danych i rozkazów, wielkość i sposób adresowania pamięci operacyjnej, rejestry programowe oraz system przerwań. Architektura specyfikuje funkcje urządzenia w odróżnieniu od implementacj i podającej struk turę logiczną i real izacj i mówiącej o budowie f izycznej .

Zgodność architektury różnych komputerów gwarantuje ich kompatybilność a więc możność przenoszenia zakodowanych programów np. na nowsze modele tej samej maszyny. Z tego powodu architektura okazuje się bardzo stałą cechą komputerów zachowywaną w niektórych rodzinach maszyn przez 20 i więcej lat (IBM 360, Intel x86, DEC VAX) mimo znacznie różniących się implementacji i dramatycznych zmian w realizacji.

W kolejnych rozdziałach opisano 7 słynnych architektur, które do dziś są realizowane w mikroprocesorach lub przynajmniej ich wpływ daje się zauważyć w produktach będących wynikiem ewolucji pierwotnych założeń. W szczególności przedstawiono pełne listy rozkazów omawianych komputerów zapisane za pomocą dość prostej samokomentującej sformalizowanej notacji.

System IBM/360 stał się w latach 60. standardem de facto w zakresie dużych komputerów (mainframes) i zapoczątkował tendencję produkowania rodzin komputerów zgodnych programowo ale mających różną moc obliczeniową a więc i różną cenę. Architektura S/360 ewoluowała przez ponad 30 lat i dziś jeszcze jest implementowana w serwerach IBM. W Polsce jest znana z maszyn serii Riad, będących klonami rodziny S/360 i S/370.

Komputery PDP-11, dzięki olbrzymiemu sukcesowi komercyjnemu, były w latach 70. synonimem minikomputera i w znacznym stopniu przyczyniły się do upowszechnienia techniki obliczeniowej. Dzięki swojej prostocie, wygodnej liście rozkazów i nowatorskiej strukturze miały wpływ na organizację logiczną powstających wówczas systemów mikroprocesorowych. Systemy te m.in. przejęły strukturę modułową zorganizowaną wokół jednej magistrali systemowej, podobnie jak to miało miejsce w PDP-11 z ich szyną UNIBUS.

Następcą PDP-11 był kolejny, uwieńczony sukcesem, produkt firmy DEC – rodzina „superminikomputerów” VAX. Architektura VAX, przejmując niektóre pomysły od swojej poprzedniczki, jest obecnie uważana za najpełniejszą realizację idei CISC (Complex Instruction Set Computer). Mnogość dostępnych typów danych, wyrafinowane funkcje niektórych instrukcji, ortogonalność i symetria listy rozkazów decydują o tym, że architektura VAX jest chyba najbardziej „elegancką” w historii komputerów.

Architektura procesora Intel 8051 wywodzi się z pierwszego historycznie mikrokomputera jednoukładowego – pełnego komputera zrealizowanego w jednym układzie scalonym. Konieczność


realizacji wielu różnorodnych funkcji w jednym układzie doprowadziła do dość skomplikowanej organizacji logicznej, osobliwego kodowania rozkazów, adresowania pamięci itd. 8051 jest do dziś jednym z najpopularniejszych 8-bitowych mikrosterowników, czyli mikroprocesorów przeznaczonych do wbudowania w urządzenie (embedded) i wykonujących stałe programy użytkowe.

Najbardziej znaną rodzinę mikroprocesorów stanowią układy Intel x86 stosowane przez IBM w komputerach osobistych od początku „ery PC”. Poczynając od modelu 80286 aż do nowych wersji Pentium, w procesorach tych są realizowane dwie, dość różniące się, architektury - korzysta się z nich w tzw. trybie rzeczywistym (organizacja 16-bitowa) lub trybie chronionym (organizacja 32-bitowa). Różnice polegają nie tylko na wielkości danych i adresów, ale też na innej zasadzie adresowania i dostępu do pamięci.

Wśród procesorów plasujących się poza głównym nurtem, niewątpliwie najważniejszym jest Transputer – opracowany przez firmę Inmos w 1983 r. Transputer, jak i przewidziany dla niego język programowania occam, nie okazały się efemerydami; transputery są produkowane w kolejno ulepszanych wersjach i z powodzeniem stosowane w systemach przetwarzania równoległego.

W początkach lat 80. pojawiła się nowa koncepcja listy rozkazów wynikająca z chęci przyspieszenia działania procesora. Od zbudowanego na Uniwersytecie w Berkeley wg tej koncepcji komputera RISC I wzięła ona nazwę Reduced Instruction Set Computing. Obecnie procesory RISC dominują rynek, na którym jedną z czołowych pozycji zajmują procesory o architekturze SPARC wywodzącej się z oryginalnej konstrukcji RISC I.

Dodatkiem do wymienionych istniejących rozwiązań jest opis prostego jednoakumulatorowego procesora nazwanego Ghibli. Jest to w istocie model dydaktyczny, dla którego podano pełny opis architektury i struktury z dokładnością do mikrooperacji sterujących. Opis ten wprowadzono m. in. dla zademonstrowania zalet sformalizowanego opisu architektury stosowanego pomocniczo we wszystkich rozdziałach.

Notacja użyta do opisu architektury jest adaptacją formalizmu ISP (Bell’a i Newell’a ) i została zdefiniowana w ostatnim rozdziale. Dzięki temu formalizmowi uzyskano pewną unifikację i jednocześnie zwięzłość opisu omawianych komputerów. Opisy słowne wskazują na osobliwości poszczególnych rozwiązań lub komentują różnice w stosunku do innych procesorów. Wszędzie, gdzie było to możliwe pozostawiono oznaczenia firmowe a nawet starano się zachować styl dokumentacji (np. zapis ósemkowy w przypadku PDP-11). W opisach list rozkazowych, oprócz funkcji rozkazu i kodu, podawano oryginalne oznaczenia asemblerowe.

Wykaz literatury ograniczono do kilku uznanych (i bardzo obszernych) pozycji książkowych i kilku wiarygodnych adresów internetowych.

Analiza opisanych architektur pokazuje z jednej strony ciągłość pewnych idei, a nawet ich konserwatyzm, a z drugiej - zaskakujące pomysły pojawiające się jakby na przekór obowiązującym tendencjom (RISC, transputer). Na przełomie stuleci nastąpi zapewne kolejna „zmiana pokoleniowa” polegająca na implementacji architektury VLIW (Very Long Instruction Word) w produktach komercyjnych. VLIW jest konsekwentnym etapem na drodze upraszczania struktury kosztem komplikacji kompilatorów. Oprócz już znanych 64-bitowych procesorów RISCowych typu Alpha czy SPARC V9 mają pojawić się, od dawna zapowiadane, procesory o architekturze IA-64: Merced i McKinley a także tajemniczy E2k (Эльбрус). Dążenie do poprawienia wydajności (performance) czyli szybkości przetwarzania powoduje stały rozwój nie tylko technologii elektronowej ale i organizacji logicznej, przy czym wydaje się, że przynajmniej w tej dziedzinie rywalizacja między tym, co wartościowe, a tym, co nowe, nie jest antagonistyczna.

Wrocław,

w styczniu A.D. 2000.


Les plaisirs demodes.

Charles Aznavour

IBM 360-370 - rodzina komputerów

Historia

Rodzina komputerów IBM Sysytem/360 została wprowadzona w r. 1964 i stała się na wiele lat punktem odniesienia dla innych producentów. Spośród wielu nowatorskich rozwiązań podstawowa była sama koncepcja rodziny maszyn, czyli wielu modeli o różnej mocy obliczeniowej i różnych konfiguracjach sprzętu ale o tej samej architekturze. Głównymi architektami byli Gene Amdahl, Fred Brooks i Gerrit Blaauw, którzy przy tej okazji upowszechnili pojęcie architektury rozumianej jako precyzyjny opis zachowania się komputera obserwowanego na poziomie języka wewnętrznego. Zgodność architektury oznacza więc kompatybilność maszyn i w efekcie (teoretyczną) możliwość przenoszenia programów.

Komputery S/360 łączyły w sobie możliwości komputerów do obliczeń naukowo-technicznych (działania na liczbach dwójkowych stało- i zmiennoprzecinkowych) i komputerów do przetwarzania danych (działania na liczbach dziesiętnych, przetwarzanie łańcuchów znakowych). Efektywna realizacja rozbudowanej listy rozkazów była możliwa dzięki zastosowaniu sterowania mikroprogramowego (jedynie najszybszy model serii 360/95 miał sterowanie układowe), które stało się standardowym rozwiązaniem we wszystkich maszynach aż do połowy lat 80. (pojawienie się komputerów typu RISC). Wszystkie te nowości oraz zastosowanie technologii układów scalonych uzasadniały zaliczenie tych maszyn do nowej, trzeciej, generacji komputerów (nazwę „S/360” rozwijano jako System Three-Sixty – „system trzeciej generacji, na lata sześćdziesiąte” albo, już zupełnie nieskromnie - „360 degree of computability”).

W latach 70. architektura S/360 z niewielkimi zmianami była implementowana w komputerach S/370, przy czym ujawniły się, wynikające z 24-bitowego adresu, ograniczenia przestrzeni adresowej do 16 Mbajtów. Przestrzeń ta poprzednio była na tyle duża, że w żadnym modelu S/360 nie została fizycznie zrealizowana. Powiększenie dostępnej pamięci było jednym z głównych celów zmian w architekturze, jakich dokonywano w następnych rodzinach dużych maszyn (mainframes) produkowanych przez IBM. W systemach 3033 i 308x obszar pamięci wirtualnej obejmował 65536 bloków 16M-bajtowych (tylko 2 bloki jednocześnie aktywne) a kolejne zmiany w tzw. architekturze rozszerzonej (XA - extended architecture) zwiększały pamięć wirtualną do 2 Gbajtów. Etapy ewolucji architektury S/360 przedstawiono w tab. ..

W Polsce i krajach d. RWPG architektura 360-370 była realizowana w komputerach tzw. Jednolitego Systemu Maszyn Cyfrowych (Riad lub EC - Единая Система ЭВМ).


Tab. 1.1. Ewolucja architektury IBM 360

Rok wprowadzenia Rodzina (modele)

1964 System/360 (20 .. 195)

1970 System/370 (115 .. 168)

1977 303x (3031, 3032, 3033)

1979 43xx (4300 .. 4381, ES/4381)

1980 308x (3081, 3083, 3084)

1986 3090 (120 .. 600, ES/3090)

1986 9370 (9370, ES/9370)

1990 System/390 (ES/9000, 120 .. 9X2)

1994 System/390 (Parallel Enterprise Server)

1996 System/390 (Multiprise Server)

Procesor centralny

Każdy komputer rodziny IBM S/360 lub S/370 zawiera procesor centralny (CPU - Central Processing Unit), pamięć główną (Main Storage) i 1-7 procesorów wejścia-wyjścia zwanych kanałami (Channels), do których przez standardowy interfejs (Standard Interface) - są dołączone urządzenia zewnętrzne (I/O Devices) wraz ze swoimi jednostkami sterującymi (Control Units). W komputerach tych stosowano adres 24-bitowy, co określało maksymalną pojemność pamięci na 16 Mbajtów:

M[0:16777215]<0:8>.

W pamięci dostępne są oprócz bajtów 16-bitowe półsłowa (halfwords), 32-bitowe słowa (words) i 64-bitowe słowa podwójne (doublewords) a także łańcuchy zmiennej długości zawierające 1-256 bajtów. Adresy półsłów, słów i słów podwójnych muszą być odpowiednio podzielne przez 2, 4 i 8 (boundary alignment). Adres jednostki wielobajtowej określa zawsze adres jej bardziej znaczącego bajta (zasada Big Endian).

Procesor ma 16 rejestrów uniwersalnych (general registers) R0..R15 o długości 32 bitów i 4 rejestry zmiennoprzecinkowe (floating-point registers) F0, F2, F4 i F6 o długości 64 bitów. Rejestry uniwersalne są stosowane do przechowywania argumentów operacji a także do tworzenia adresów efektywnych tych argumentów. Ponieważ numer rejestru jest zawsze kodowany w 4-bitowym polu słowa rozkazowego, to wybór rejestru uniwersalnego bądź zmiennoprzecinkowego zależy od kontekstu: w rozkazach zmiennoprzecinkowych argumenty są tylko w rejestrach zmiennoprzecinkowych; w pozostałych rozkazach - tylko w rejestrach uniwersalnych. W polu adresującym pamięć występują tylko rejestry uniwersalne.

Informacja o stanie komputera i stanie wykonywanego programu jest zawarta słowie stanu programu (PSW - Program Status Word). Jest to słowo 64-bitowe, w którym niektóre pola zmieniają swoją wartość po każdym rozkazie, inne po przyjęciu przerwania a inne są ustawiane programowo (przez program nadzorczy- Supervisor) i spełniają rolę informacji sterującej działanie maszyny.

Są dwa formaty PSW: format BC (basic control mode) - jedyny format stosowany w systemie S/360 i format EC (extended control mode) - wprowadzony systemie S/370. Wyróżnikiem jest bit <12> przewidziany pierwotnie dla określenia aktualnego kodu zewnętrznego: ASCII-8 lub EBCDIC. Ponieważ w systemie S/360 kod ASCII nie był nigdy używany przyjęto, że PSW<12>=0 definiuje format BC a PSW<12>=1 - format EC.

W formacie BC poszczególne pola pełnią następujące role:


Pole <40:63> zawiera pełny 24-bitowy adres następnego rozkazu i stanowi odpowiednik licznika rozkazów w innych maszynach sekwencyjnych.

Pole <32:33> zawiera kod długości ostatnio wykonywanego rozkazu (ILC - Instruction Length Code) i umożliwia odtworzenie adresu ostatniego rozkazu. Kodowanie jest tu następujące:

01 - 1 półsłowo (rozkazy RR),

10 - 2 półsłowa (rozkazy RX, RS lub SI),

11 - 3 półsłowa (rozkazy SS).

0 6 7 8 11 12 16 31

A M W P Kod przerwania

Maski kanałów Klucz Stan Problem/Supervisor

ochrony Stan Wait/Run Maska Maska kontroli maszyny przerwań

zewnętrznych Kod ASCII/EBCDIC

32 34 36 40 63

ILC CC Adres następnego rozkazu

Maski 4 przerwań programowych

Rys. 1.1. IBM 360-370. Słowo stanu programu (PSW) w formacie BC

Pole <34:35> zawiera kod warunków ostatnio wykonanej operacji (CC - Condition Code) i umożliwia zakodowanie jednego z 4 warunków. Jest 11 różnych interpretacji tego kodu - zależnie od rodzaju wykonywanej operacji; np. dla niektórych rozkazów interpretacja CC ma postać (a) a dla innych (b):

(a) (b) 00 - wynik = 0 00 - wynik = 0

01 - wynik < 0 01 - wynik 0 10 - wynik > 0 11 - nadmiar

Taki sposób zapisywania warunków różni się od najczęściej obecnie stosowanego sposobu z użyciem znaczników binarnych przypisanych do różnych sytuacji (np. wynik zerowy, ujemny, nadmiar, parzystość itp.); ma to swoje konsekwencje w kodowaniu rozkazów warunkowych.

W PSW zapisane są też tzw. maski przerwań określające wrażliwość systemu na nadchodzące żądania przerwań. Globalnie maskowane są przerwania zewnętrzne (pole <7>) i przerwania kontroli maszyny (pole <13>). Przerwania wejścia-wyjścia są maskowane dla poszczególnych kanałów (pole <0:6>) a przerwania programowe wybiórczo - można zamaskować tylko 4 przerwania spośród 15 możliwych: nadmiar stałopozycyjny i dziesiętny, podmiar wykładnika i zero mantysy (pole <36:39>).

Przerwanie jest przyjmowane, jeżeli odpowiedni bit PSW ma wartość 1. Po przyjęciu przerwania, w polu <16:31> jest wpisywany jego identyfikator potrzebny do powołania przez program nadzorczy właściwego programu obsługi. Pole <8:11> stanowi 4-bitowy klucz ochrony stosowany do ochrony pamięci w niektórych modelach rodziny 360-370. Przy każdym kontakcie procesora z pamięcią klucz ochrony (z bieżącego PSW) jest porównywany z kluczem pamięci przypisanym przez program nadzorczy do każdego 2 Kbajtowego bloku pamięci i pamiętanego w specjalnej pamięci kluczy oznaczanej dalej jako KM:

KM[0:8191]<0:4>.

Jeżeli oba klucze są identyczne, to może nastąpić zarówno zapisanie jak i odczytanie pamięci; jeżeli klucze różnią się, wówczas decyduje dodatkowy piąty bit klucza pamięci: jeżeli ma on wartość 0 - możliwe jest tylko odczytanie pamięci, jeżeli ma wartość 1 - nie można ani czytać ani zapisywać. Próba naruszenia ochrony powoduje przerwanie programowe.


Pola <14> i <15> określają dwie pary wyłączających się stanów procesora. Pole <14> określa stan normalnej pracy (Run) lub stan oczekiwania na przerwanie (Wait). W stanie oczekiwania nie wykonują się żadne rozkazy natomiast działa zegar i są przyjmowane przerwania.

Pole <15> określa czy procesor wykonuje program użytkownika (Problem) czy program nadzorczy (Supervisor). Różnica jest istotna i dotyczy zakresu władzy nad systemem; w stanie Problem niektóre rozkazy (tzw. rozkazy uprzywilejowane) nie są dostępne. Próba użycia rozkazu uprzywilejowanego (np. zmieniającego PSW, ustalającego klucze pamięci, rozkazu wejścia-wyjścia) powoduje niemaskowalne przerwanie programowe.

W systemie S/370 wprowadzono nowe rejestry sterujące (control registers) przechowujące informacje dotyczące m.in. kontroli maszyny, wieloprzetwarzania i zarządzania pamięcią - w związku ze stosowaniem pamięci wirtualnej. Do rejestrów sterujących przeniesiono także niektóre informacje dotyczące przerwań - pamiętane poprzednio w PSW. Nowy format słowa PSW przedstawia rys.1.2.. Klucz ochrony, kody MWP i adres następnego rozkazu pozostały na swoich miejscach. Kod warunków i maska programu znalazły się na pozycjach <18:23>. Maski kanałów zostały umieszczone w rejestrze sterującym CR2 a bit PSW<6> wskazuje czy wszystkie przerwania we/wy są zamaskowane (PSW<6>=0) czy obowiązują maski z rejestru CR2. Analogiczną funkcję pełni bit PSW<7> i rejestr CR0 w stosunku do przerwań zewnętrznych. Bit PSW<5> określa dynamiczną translację adresów wirtualnych; gdy PSW<5>=0 translacja jest wyłączona. Bit PSW<1> steruje wraz z rejestrami CR9 - CR11 rejestracją zdarzeń programowych.

0 1 2 3 4 5 6 7 8 11 12 16 18 20 24 31

0 R 0 T I E 1 M W P 0 0 CC 0

Klucz Stan Problem/Supervisor Maski 4 przerwań

ochrony Stan Wait/Run programowych

Maska kontroli maszyny

Znacznik formatu EC

32 40 63

0 Adres następnego rozkazu

Rys. 1.2. Słowo stanu programu (PSW) w formacie EC

Formaty danych

Argumentami operacji mogą być:

liczby dwójkowe całkowite w kodzie uzupełnieniowym U2 (16- i 32-bitowe),

liczby dwójkowe zmiennopozozycyjne (32- , 64- i 128-bitowe),

liczby dziesiętne spakowane (do 31 cyfr BCD) i rozpakowane (do 16 cyfr BCD),

łańcuchy znaków (do 256 bajtów).

Liczby zmiennoprzecinkowe (floating-point numbers) wg standardu IBM 360/370 mają format

s e f

1 7 24 / 56 / 120

i interpretację

(-1)s 16

e - 64 (0.f)

Zakres przedstawianych modułów liczb nie zależy od formatu i wynosi od 5,4*10-79

do 7,2*1075

, natomiast dokładność wyrażona w cyfrach dziesiętnych jest 7 - dla liczb krótkich, 17 - dla długich i 34 - dla podwójnych liczb zmiennoprzecinkowych.


Liczby dziesiętne spakowane (packed decimal numbers) mają długość od 1 do 16 bajtów (określoną w polu L1 i L2 słowa rozkazowego typu SS), co pozwala zapisać do 31 cyfr – po dwie cyfry BCD w jednym bajcie, przy czym znak liczby kodowany jest w drugiej tetradzie ostatniego bajta (+ jako 1100, - jako 1101). Np. liczba - 25 478 556 umieszczona w pamięci pod adresem 34567 zajmuje 5 bajtów i ma postać szesnastkową:

Adres: 34567 23568 34569 34570 34571

0 2 5 4 7 8 5 5 6 D

Liczby dziesiętne rozpakowane (zoned decimal numbers) też mają zmienną długość (do 16 bajtów), co pozwala zapisać jedynie 15 cyfr gdyż pierwsza tetrada bajta zawiera tzw. „strefę” równą 1111 a w drugiej znajduje się kod BCD cyfry (w efekcie każdy bajt koduje cyfrę dziesiętną w kodzie EBCDIC). Znak liczby kodowany jest w pierwszej tetradzie ostatniego bajta (na miejscu „strefy”). Np. liczba + 54321 ma w pamięci postać (szesnastkową):

F 5 F 4 F 3 F 2 C 1

Łańcuchy znaków (byte strings) są argumentami rozkazów typu SS i mają długość od 1 do 256 bajtów kodowaną w 8-bitowym polu L tych rozkazów. Łańcuchy te zawierają znaki kodu alfanumerycznego EBCDIC (character string) lub informację binarną (binary string). Np. tekst „Rok 1948” ma postać 8-bajtowego łańcucha:

D 9 9 6 9 2 4 0 F 1 F 9 F 4 F 8

Ogólnie, interpretacja zawartości pamięci zależy od kontekstu, w jakim jest generowany adres, np. jeżeli fragment pamięci ma postać

Adres (dzies) Zawartość (hex)

84576 46

84577 35

84578 2D

84579 17

to spod adresu 84576 można odczytać:

liczbę całkowitą krótką 46 35 (hex) czyli + 17 973,

liczbę całkowitą długą 46 35 2D 17 (hex) czyli + 1 177 890 071,

liczbę zminnopozycyjną krótką 46 35 2D 17 (hex) czyli 166 * 0,352D17h = + 3 484 957,

5-cyfrową liczbę dziesiętną spakowaną 46 35 2D (hex) czyli - 46 352,

rozkaz typu RX : kod operacji 46 („Branch on Count”), argumenty w R3 i w pamięci pod adresem R5+R2+D17h.

Kodowanie rozkazów

Jest 5 podstawowych formatów rozkazów (rys. 1.3) określanych od miejsca przechowywania argumentów jako RR (register-to-register), RX (register-to-indexed storage), RS (register-to-storage), SI (storage and immediate) i SS (storage-to-storage). Rozkazy są kodowane na 2, 4 lub 6 bajtach, przy czym zawsze pierwszy bajt zawiera kod operacji implikując jednocześnie format rozkazu. Argument operacji może znajdować się w rejestrze (uniwersalnym lub zmiennoprzecinkowym) i wtedy do jego wskazania wystarcza 4-bitowe pole ri bądź w pamięci i wówczas musi być określony jego adres efektywny eai (tab. ). Adres ten jest zawsze adresem względnym obliczanym jako suma zawartości rejestru bazowego Rbi i 12-bitowego przesunięcia (displacement) Di, traktowanego jako liczba z zakresu 0..4095:

eai = R[bi] + Di


Wskaźnik i określa tu składniki adresu i-go argumentu. Jeżeli pole bi ma wartość 0, to nie bierze się rejestru R0 lecz składnik R[bi] jest pomijany. Np. Rozkaz Exclusive OR formatu RR obliczający różnicę symetryczną R12 i R3 z umieszczeniem wyniku w R12 ma kod szesnastkowy

17 C3

a w języku asemblera zapisuje się jako XR 12,3

W rozkazach formatu RX adres może być dodatkowo indeksowany zawartością rejestru wskazanego w polu x2:

ea2 = R[b2] + R[x2] + D2 Np. mnożenie stałopozycyjne (Multiply) rejestru R7 przez mnożnik umieszczony pod adresem (R9 + R11 + 245h) z wynikiem w połączonych rejestrach R6 i R7 ma kod

5C 69 B2 45

i zapis asemblerowy M 6,X'245'(9,11)

Rozkazy RS są 3-argumentowe, przy czym argumenty 1. i 3. muszą być w rejestrach. Np. zapamiętanie rejestrów (STore Multiple) R5..R11 w kolejnych miejscach pamięci poczynając od adresu (R3 + 26) ma kod

90 5B 30 1A

i zapis STM 5,11,26(3)

Rozkazy SI mają argument bezpośredni, zapisany w rozkazie na 8-bitowym polu I2; interpretacja tej stałej zależy od rodzaju operacji. Np. rozkaz MoVe Immediate wpisujący wartość F0h do bajta o adresie (R5 + 24) ma kod

92 F0 50 18

i zapis asemblerowy MVI 24(5),X'F0'

Należy tu zwrócić uwagę, że stałe występujące w rozkazach asemblerowych, tzw. literały, nie muszą być kodowane w polu I rozkazów SI. Literały, będące danymi dowolnego dopuszczalnego typu (liczby całkowite, zmiennoprzecinkowe, dziesiętne, znaki alfanumeryczne, adresy), są umieszczane przez program asemblujący w specjalnej tablicy literałów i adres dotyczący tej tablicy, a nie sam literał, jest wpisywany do kodu rozkazu. Format SS jest przeznaczony do kodowania operacji na liczbach dziesiętnych i na łańcuchach bajtów. Np. przesłanie 72-bajtowego łańcucha znaków (MoVe Characters) spod adresu (R4 + 14) na miejsce zaczynające się pod adresem (R5 + 20) ma kod

D2 48 50 14 40 0E

i postać asemblerową: MVC 20(72,5),14(4)

Działania na łańcuchach bajtów dotyczą argumentów jednakowej długości zakodowanej w polu L; łańcuchy te mogą mieć długość od 1 do 256 bajtów (L+ 1). Argumenty są 1przetwarzane zaczynając od lewej do prawej strony (od najbardziej znaczącego bajta).,

W działaniach dziesiętnych argumenty mogą się różnić długością określoną, odpowiednio, w polu L1 i L2; liczba bajtów argumentu i wynosi Li + 1 a adres pierwszego (najbardziej znaczącego bajta) jest R[bi] + Di. Taki sposób kodowania pozwala wskazywać liczby (w formacie spakowanym) o długości od 1 do 31 cyfr dziesiętnych. Argumenty takich rozkazów są przetwarzane od prawej strony do lewej (od najmniej znaczącego bajta). Np. spakowanie (Pack) 5-bajtowej liczby dziesiętnej spod adresu określonego przez bazę R12 i przesunięcie A82h oraz umieszczenie wyniku na trzech bajtach pod adresem (R12 + 248h) ma kod

F2 24 C2 48 CA 82

i zapis asemblerowy: PACK X'248'(2,12),X'A82'(4,12)

Rozkazy typu S są stosowane wyłącznie w IBM S/370 i są to rozkazy uprzywilejowane. Jedyny argument tych rozkazów nazywany jest w dokumentacji firmowej argumentem drugim. Kod operacyjny zajmuje dwa bajty. Np. zapamiętanie stanu zegara dobowego (time-of-day clock) w 64-bitowym słowie pod adresem (R5 + 24) ma kod

B2 05 50 18


i zapis asemblerowy (STore ClocK) STCK 24(5)

0 7 8 15

RR Kod op. r1 r2

0 7 8 15 20 31

RX Kod op. r1 x2 b2 D2

0 7 8 15 20 31

RS Kod op. r1 r3 b2 D2

0 7 8 15 20 31

SI Kod op. I2 b1 D1

0 7 8 15 20 31 32 47

SS Kod op. L b1 D1 b2 D2

0 7 8 15 20 31 32 47

SS Kod op. L1 L2 b1 D1 b2 D2

0 15 20 31

S Kod op. b2 D2

Rys. 1.3. IBM 360-370. Formaty rozkazów

Tab. 1.2. IBM 360-370. Wyznaczanie argumentów w rozkazach różnych typów

Typ

Argumenty

Zapis asemblerowy

RR R[r1] R[r2] - Kod r1,r2

RX R[r1] M[R[b2]+R[x2]+D2] - Kod r1,D2(x2,b2)

RS R[r1] M[R[b2]+D2] R[r3] Kod r1,r3,D2(b2)

SI M[R[b1]+D1] I2 - Kod D1(b1),I2

SS M[R[b1]+D1] M[R[b2]+D2] - Kod D1(L,b1),D2(b2)

SS M[R[b1]+D1] M[R[b2]+D2] - Kod D1(L1,b1),D2(L2,b2)

S - M[R[b2]+D2] - Kod D2(b2)

W dalszym ciągu opisu dla adresów efektywnych pamięci stosowane są oznaczenia ea1 i ea2. Np. adres drugiego argumentu rozkazów RX ma wartość ea2 = R[b2] + R[x2] + D2.


Lista rozkazów

Opisano podstawową listę rozkazów (bez rozszerzeń w rodzinie 370 i późniejszych). Pominięto dokładny opis działania rozkazów wejścia-wyjścia (SIO, TIO, HIO, TCH), rozkazów edycji (ED, EDMK) i diagnostyki (DIG) ze względu na konieczność definiowania wówczas architektury bloków pozaprocesorowych (np. kanałów we-wy). W opisie działań zastosowano skrócone komentarze w nawiasach klamrowych precyzujące typ argumentów i operacji; brak tego typu komentarza oznacza działanie w kodzie dwójkowym uzupełnieniowym (U2):

{dec} – liczba dziesiętna, {flp} – liczba zmiennoprzecinkowa wg formatu IBM, {nrm} – postać znormalizowana zmiennoprzecinkowa, {pk} – postać dziesiętna spakowana, {up} – postać dziesiętna rozpakowana, {us} – liczba dwójkowa bez znaku.

Rozmiar argumentu zaznaczono tam, gdzie jest różny od domyślnego – np. połowa 64-bitowego rejestru zmiennoprzecinkowego: F[r2]<0:31>, 6 bitów 24-bitowego adresu efektywnego: ea2<18:23>, dwusłowowy argument spod adresu ea1 w pamięci: M[ea1]<0:63> itp.

Rozkazy działań arytmetycznych

Dostępne są tylko 4 podstawowe działania arytmetyczne, ale istnieją osobne rozkazy dla każdego typu argumentów: liczb dwójkowych stało- i zmienno-przecinkowych oraz dziesiętnych liczb spakowanych (tablice 1.3 - 1.5). Liczbę rozkazów tej grupy dodatkowo powiększa ich specjalizacja zależnie od wielkości argumentów (krótkie – długie) i ich umiejscowienia (w rejestrach – w pamięci). Tab. 1.3. IBM 360-370. Rozkazy działań arytmetycznych na liczbach stałopozycyjnych

Oznaczenie

Kod

Format

Działanie

Obydwa argumenty w rejestrach

AR 1A RR R[r1] R[r1] + R[r2]

SR 1B RR R[r1] R[r1] – R[r2]

MR 1C RR R[r1]^R[r1+1] R[r1+1] * R[r2]

DR 1D RR R[r1+1] R[r1]^R[r1+1] / R[r2]

ALR 1E RR R[r1] R[r1] + R[r2] {us}

SLR 1F RR R[r1] R[r1] – R[r2] {us}

Jeden argument w pamięci

AH 4A RX R[r1]< 0:15> R[r1]< 0:15> + M[ea2]<0:15>

SH 4B RX R[r1]< 0:15> R[r1]< 0:15> – M[ea2]<0:15>

MH 4C RX R[r1] R[r1+1] <0:15> * M[ea2]<0:15>

A 5A RX R[r1] R[r1] + M[ea2]<0:31>

S 5B RX R[r1] R[r1] – M[ea2]<0:31>

M 5C RX R[r1]^R[r1+1] R[r1+1] * M[ea2]<0:31>

D 5D RX R[r1+1] R[r1]^R[r1+1] / M[ea2]<0:31>

AL 5E RX R[r1] R[r1] + M[ea2]<0:31> {us}

SL 5F RX R[r1] R[r1] – M[ea2]<0:31> {us}

Dla liczb dwójkowych są osobne rozkazy dodawania i odejmowania „logicznego” (add logical, substract logical), przez co rozumie się traktowanie argumentów jako liczb dodatnich bez znaku (ALR, SLR, AL, SL).

Dla liczb zmiennoprzecinkowych wyróżniono rozkazy dodawania i odejmowania nie normalizujące wyniku (unnormalized - AU, SU, AUR, SUR, AWR, SWR); wszystkie pozostałe zapisują wynik znormalizowany.


Działania dziesiętne dokonują się na liczbach o długości zdefiniowanej w rozkazie, przy czym oba argumenty mogą mieć różną długość. Np. rozkaz ZAP „zeruj i dodaj” (Zero and Add), będący w istocie rozkazem przesłania, wpisuje drugi argument na miejsce pierwszego ewentualnie uzupełniając zerami bajty od strony bardziej znaczących pozycji.

Tab. 1.4. IBM 360-370. Rozkazy działań na liczbach zmiennoprzecinkowych

Oznaczenie

Kod

Format

Działanie

Argumenty 64-bitowe; oba argumenty w rejestrach

ADR 2A RR F[r1] F[r1] + F[r2] {flp,nrm}

SDR 2B RR F[r1] F[r1] – F[r2] {flp,nrm}

MDR 2C RR F[r1] F[r1] * F[r2] {flp,nrm}

DDR 2D RR F[r1+1] F[r1] / F[r2] {flp,nrm}

AWR 2E RR F[r1] F[r1] + F[r2] {flp}

SWR 2F RR F[r1] F[r1] – F[r2] {flp}

Argumenty 64-bitowe; jeden argument w pamięci

AD 6A RX F[r1] F[r1] + M[ea2]<0:63> {flp,nrm}

SD 6B RX F[r1] F[r1] – M[ea2]<0:63> {flp,nrm}

MD 6C RX F[r1] F[r1] * M[ea2]<0:63> {flp,nrm}

DD 6D RX F[r1+1] F[r1] / M[ea2]<0:63> {flp,nrm}

AW 6E RX F[r1] F[r1] + M[ea2]<0:63> {flp}

SW 6F RX F[r1] F[r1] – M[ea2]<0:63> {flp}

Argumenty 32-bitowe; oba argumenty w rejestrach

AER 3A RR F[r1]<0:31> F[r1]<0:31> + F[r2]<0:31> {flp,nrm}

SER 3B RR F[r1]<0:31> F[r1]<0:31> – F[r2]<0:31> {flp,nrm}

MER 3C RR F[r1]<0:31> F[r1]<0:31> * F[r2]<0:31> {flp,nrm}

DER 3D RR F[r1]<0:31> F[r1]<0:31> / F[r2]<0:31> {flp,nrm}

AUR 3E RR F[r1]<0:31> F[r1]<0:31> + F[r2]<0:31> {flp}

SUR 3F RR F[r1]<0:31> F[r1]<0:31> – F[r2]<0:31> {flp}

Argumenty 32-bitowe; jeden argument w pamięci

AE 7A RX F[r1]<0:31> F[r1]<0:31> + M[ea2]<0:31> {flp,nrm}

SE 7B RX F[r1]<0:31> F[r1]<0:31> – M[ea2]<0:31> {flp,nrm}

ME 7C RX F[r1]<0:31> F[r1]<0:31> * M[ea2]<0:31> {flp,nrm}

DE 7D RX F[r1]<0:31> F[r1]<0:31> / M[ea2]<0:31> {flp,nrm}

AU 7E RX F[r1]<0:31> F[r1]<0:31> + M[ea2]<0:31> {flp}

SU 7F RX F[r1]<0:31> F[r1]<0:31> – M[ea2]<0:31> {flp}


Tab. 1.5. IBM 360-370. Rozkazy działań arytmetycznych na liczbach dziesiętnych

Oznaczenie

Kod

Format

Działanie

AP FA SS M[ea1] M[ea1] + M[ea2] {dec}

SP FB SS M[ea1] M[ea1] – M[ea2] {dec}

MP FC SS M[ea1] M[ea1] * M[ea2] {dec}

DP FD SS M[ea1] M[ea1] / M[ea2] {dec}

ZAP F8 SS (L1>L2) => M[ea1:ea1+L1-L2-1] 0;

M[ea1+L1-L2:ea1+L1] M[ea2:ea2+L2];

(L1L2) => M[ea1:ea1+L1] M[ea2:ea2+L1];

Rozkazy działań logicznych

Są tylko 3 operacje boolowskie – koniunkcja, alternatywa i różnica symetryczna; każda z nich występuje w trzech wersjach zależnych od argumentów (tab.1.6). Rozkazy z argumentem bezpośrednim (NI, OI, XI) działają na bajtach; pozostałe dotyczą słów 32-bitowych.

Tab. 1.6. IBM 360-370. Rozkazy działań logicznych

Oznaczenie

Kod

Format

Działanie

NR 14 RR R[r1] R[r1] and R[r2]

N 54 RX R[r1] R[r1] and M[ea2]<0:31>

NI 94 SI M[ea1] M[ea1] and I2

OR 16 RR R[r1] R[r1] or R[r2]

O 56 RX R[r1] R[r1] or M[ea2]<0:31>

OI 96 SI M[ea1] M[ea1] or I2

XR 17 RR R[r1] R[r1] xor R[r2]

X 57 RX R[r1] R[r1] xor M[ea2]<0:31>

XI 97 SI M[ea1] M[ea1] xor I2

Rozkazy przesunięć

W grupie przesunięć możliwe są przesunięcia naturalne i przesunięcia arytmetyczne, nie ma natomiast przesunięć cyklicznych. Przesunięcia mogą być wielopozycyjne, liczbę przesunięć koduje się na 6 bitach formalnego adresu ea2. Argumentem jest zawsze zawartość rejestru lub pary sąsiednich rejestrów wskazana w polu r1 rozkazu. Pewną osobliwością jest istnienie arytmetycznego przesunięcia w lewo (SLA i SLDA).

Tab. 1.7. IBM 360-370. Rozkazy przesunięć

Oznaczenie

Kod

Format

Działanie

SRL 88 RS R[r1] ea2<18:23> shr R[r1]

SLL 89 RS R[r1] ea2<18:23> shl R[r1]

SRA 8A RS R[r1] ea2<18:23> shra R[r1]

SLA 8B RS R[r1] ea2<18:23> shla R[r1]

SRDL 8C RS R[r1]^R[r1+1] ea2<18:23> shr R[r1]^R[r1+1]

SLDL 8D RS R[r1]^R[r1+1] ea2<18:23> shl R[r1]^R[r1+1]

SRDA 8E RS R[r1]^R[r1+1] ea2<18:23> shra R[r1]^R[r1+1]

SLDA 8F RS R[r1]^R[r1+1] ea2<18:23> shla R[r1]^R[r1+1]


Rozkazy przesłań

Specyfiką tej grupy operacji jest łączenie przesłania ze zmianą przesyłanego argumentu i ustawianiem kodu warunków CC. I tak: LCR (Load Complement) przesyła argument stałopozycyjny ze zmianą znaku, LPR (Load Positive) zmienia argument na dodatni, a LNR (Load Negative) – na ujemny. Analogiczne rozkazy istnieją dla liczb zmiennoprzecinkowych: LCDR i LCER, LPDR i LPER oraz LNDR i LNER.

Rozkazy HER i HDR (Halve) dzielą przesyłaną liczbę zmiennoprzecinkową przez 2.

Tab. 1.8. IBM 360-370. Rozkazy przesłań

Oznaczenie

Kod

Format

Działanie

LR 18 RR R[r1] R[r2]

LTR 12 RR R[r1] R[r2]; ustawianie CC

LCR 13 RR R[r1] notR[r2] + 1

LPR 10 RR (R[r2]<0>=1) => R[r1] notR[r2] + 1; (R[r2]<0>=0) => R[r1] R[r2]

LNR 11 RR (R[r2]<0>=0) => R[r1] notR[r2] + 1; (R[r2]<0>=1) => R[r1] R[r2]

L 58 RX R[r1] M[ea2]

LH 48 RX R[r1]<0:15> M[ea2]<0:15>

LD 68 RX F[r1] M[ea2]<0:63>

LDR 28 RR F[r1] F[r2]

LTDR 22 RR F[r1] F[r2]; ustawianie CC

LCDR 23 RR F[r1] notF[r2]<0>^F[r2]<1:63>

LPDR 20 RR F[r1] 0^F[r2]<1:63>

LNDR 21 RR F[r1] 1^F[r2]<1:63>

HDR 24 RR F[r1] F[r2]/2 {flp}

LE 78 RX F[r1]<0:31> M[ea2]<0:31>

LER 38 RR F[r1]<0:31> F[r2] <0:31>

LTER 32 RR F[r1]<0:31> F[r2] <0:31>; ustawianie CC

LCER 33 RR F[r1]<0:31> notF[r2]<0>^F[r2]<1:31>

LPER 30 RR F[r1]<0:31> 0^F[r2]<1:31>

LNER 31 RR F[r1]<0:31> 1^F[r2]<1:31>

HER 34 RR F[r1]<0:31> F[r2] <0:31>/2 {flp}

STH 40 RX M[ea2]<0:15> R[r1]<16:31>

STC 42 RX M[ea2]<0:7> R[r1]<24:31>

ST 50 RX M[ea2]<0:31> R[r1]

STE 70 RX M[ea2]<0:31> F[r1]<0:31>

STD 60 RX M[ea2]<0:63> F[r1]

SM 90 RS r r1; a ea2; next M[a]<0:31> R[r]; next

rep ((rr3) => r r+1{mod16}; a a+4; next M[a]<0:31> R[r])

MVI 92 SI M[ea1]<0:7> I2

LA 41 RX R[r1] ea2

IC 43 RX R[r1]<24:31> M[ea2]<0:7>

LM 98 RS r r1; a ea2; next R[r] M[a]<0:31>; next

rep ((rr3) => r r+1{mod16}; a a+4; next R[r] M[a]<0:31>)


Rozkazy testowania

Rozkazy porównań (Compare) służą do ustawiania warunków po to aby następnie można zastosować rozkaz skoku warunkowego (BC lub BCR) rozgałęziający przebieg programu.

Wszystkie porównania odbywają się przez odejmowanie a różnorodność rozkazów wynika z osobnych kodów dla różnych typów argumentów i różnej ich lokalizacji. Przy porównaniu żaden argument nie ulega zmianie a jedynie ustawiane są dwa bity w polu CC słowa stanu PSW.

Specyficzny jest rozkaz TM (Test under Mask), w którym argument bezpośredni (I2) traktowany jest jako maska wybierająca bity badane w bajcie pod adresem ea1. Jeżeli wybrane bity są zerami lub maska zawiera same zera wówczas CC=00, jeżeli wybrane bity są jedynkami, to CC=11; w innych przypadkach CC=01. Tab. 1.9. IBM 360-370. Rozkazy testowania

Oznaczenie

Kod

Format

Ustawienie warunków CC wg wyników operacji

Porównanie liczb całkowitych

C 59 RX R[r1] – M[ea2]<0:31>

CH 49 RX arg <0:31> M[ea2]<0:15>; next R[r1] – arg

CL 55 RX R[r1] – M[ea2]<0:31> {us}

CLC D5 SS M[ea1]<0:7+8*L> – M[ea2]<0:7+8*L> {us}

CLI 95 SI M[ea1] – I2 {us}

CLR 15 RR R[r1] – R[r2] {us}

CR 19 RR R[r1] – R[r2]

Porównanie liczb zmiennoprzecinkowych

CD 69 RX F[r1] – M[ea2]<0:63> {flp,nrm}

CDR 29 RR F[r1] – F[r2] {flp}

CE 79 RX F[r1]<0:31> – M[ea2]<0:31> {flp,nrm}

CER 39 RR F[r1]<0:31> – F[r2]<0:31> {flp}

Porównanie liczb dziesiętnych

CP F9 SS M[ea1]<0:7+8*L1> – M[ea2]<0:7+8*L2> {dec}

Testowanie logiczne bajta

TM 91 SI M[ea1] and I2

Rozkazy konwersji

Możliwe są zmiany postaci dziesiętnej na dwójkową i odwrotnie oraz zmiana formatu liczb dziesiętnych (spakowany na rozpakowany i odwrotnie).

Tab. 1.10. IBM 360-370. Rozkazy zmiany typu danych

Oznaczenie

Kod

Format

Działanie

CVD CVB PACK UNPK

4E 4F F2 F3

RX RX SS SS

M[ea2]<0:63>{dec} R[r1]<0:31>{bin}

R[r1]<0:31>{bin} M[ea2]<0:63>{dec}

M[ea1]<0:7+8*L1>{pk dec} M[ea2]<0:7+8*L2>{up dec}

M[ea1]<0:7+8*L1>{up dec} M[ea2]<0:7+8*L2>{pk dec}


Rozkazy działań na łańcuchach znaków

Rozkazy działające na łańcuchach pozwalają na różnorodne ich przesyłania oraz na wykonywanie na nich działań boolowskich.

MVC (Move Characters) przesyła kolejne bajty (od lewego) bez ich zmiany. MVN (Move Numerics) przepisuje do łańcucha docelowego tylko 4 mniej znaczące bity z każdego bajta, przy czym nie muszą to być koniecznie kody cyfr dziesiętnych; pozostałe bity nie ulegają zmianie. Rozkaz MVZ (Move Zones) przepisuje tylko 4 bardziej znaczące bity (tzw. „strefę”) każdego bajta.

Rozkaz MVO (Move with Offset) przepisuje łańcuch źródłowy z jednoczesnym przesunięciem o 4 bity w lewo; skrajna prawa tetrada całego łańcucha pozostaje w łańcuchu docelowym niezmieniona a ewentualne wolne tetrady na lewym skraju łańcucha docelowego są zerowane.

Rozkazy NC OC i XC wykonują na podanych łańcuchach odpowiednio operacje (bitowe) iloczynu logicznego, sumy logicznej i różnicy symetrycznej.

Rozkaz TR (Translate) tłumaczy źródłowy łańcuch bajtów wg tablicy kodowej podanej jako drugi argument łańcuchowy. Każda kombinacja kodowa źródła jest traktowana jako indeks tablicy kodowej, której zawartość wpisuje się na miejsce oryginału. Jeżeli drugi argument ma długość 256 bajtów, to translacja jest zdefiniowana dla każdej kombinacji bitów w znaku. TRT (Translate and Test) sprawdza ciąg bajtów i ustawia kod warunków po znalezieniu zadanej kombinacji bitów.

Tab. 1.11. IBM 360-370. Rozkazy działań na łańcuchach znaków

Oznaczenie

Kod

Format

Działanie

MVC D2 SS len L; next rep((len 0) => M[ea1] M[ea2]; next

ea1 ea1+1; ea2 ea2+1; len len-1)

MVN D1 SS len L; next rep((len 0) => M[ea1]<4:7> M[ea2]<4:7>; next


MVZ D3 SS len L; next rep((len 0) => M[ea1]<0:3> M[ea2]<0:3>; next


MVO F1 SS Przesłanie z przesunięciem w lewo o 4 bity

NC D4 SS M[ea1]<0:(7+8*L)> M[ea1]<0:(7+8*L)> and M[ea2]<0:(7+8*L)>

OC D6 SS M[ea1]<0:(7+8*L)> M[ea1]<0:(7+8*L)> or M[ea2]<0:(7+8*L)>

XC D7 SS M[ea1]<0:(7+8*L)> M[ea1]<0:(7+8*L)> xor M[ea2]<0:(7+8*L)>

TR DC SS len L; next rep((len 0) => M[ea1] M[ea2+ M[ea1]<0:7>]; next

ea1 ea1+1; len len-1)

TRT DD SS len L; next rep((M[ea2+ M[ea1]<0:7>] = 0) and ((len 0)) =>

ea1 ea1+1; len len-1); next

R1<8:31> ea1; R2<24:31> M[ea2+ M[ea1]]<0:7>

ED DE SS Redagowanie danych dziesiętnych spakowanych

EDMK DF SS Redagowanie danych dziesiętnych spakowanych

Rozkazy skokowe

W opisie rozkazów skokowych (tab. 1.12) przyjęto symbol PC na oznaczenie pola w PSW określającego adres następnego rozkazu:

PC := PSW<32:63>.

Skoki warunkowe wykonują się gdy jest spełniony warunek cond zakodowany na bitach <8:11> słowa rozkazowego (w tych rozkazach pole r1 spełnia rolę 4-bitowej maski przerwań oznaczanej dalej jako m<0:3>). Skok jest efektywny, jeżeli w polu CC słowa stanu PSW jest którakolwiek z wartości wybranych przez maskę:

cond := m<0>&(CC=0) or m<1>&(CC=1) or m<2>&(CC=2) or m<3>&(CC=3)

Wartość m = 1111b powoduje, że skok jest bezwarunkowy, zaś m = 0000b degeneruje rozkazy BC i BCR do rozkazu „nic nie rób”, który jawnie nie występuje w liście rozkazów.

Bardzo oryginalną funkcję pełni rozkaz EX (Execute), który działa jak jednorozkazowy podprogram o strukturze komponowanej przez użytkownika.


Tab. 1.12. IBM 360-370. Rozkazy sterujące przebieg programu

Oznaczenie

Kod

Format

Działanie

BCR 07 RR cond => PC R[r2]

BC 47 RX cond => PC ea2

BALR 05 RR R[r1] PC; next PC R[r2]

BAL 45 RX R[r1] PC; next PC ea2

BCTR 06 RR R[r1] R[r1] – 1; next (R[r1] 0) => PC R[r2]

BCT 46 RX R[r1] R[r1] – 1; next (R[r1] 0) => PC ea2

BXH 86 RS R[r1] R[r1] + R[r3]; next (R[r3+1] < R[r1]) => PC ea2

BXLE 87 RS R[r1] R[r1] + R[r3]; next (R[r3+1] R[r1]) => PC ea2

EX 44 RX wykonanie rozkazu ins o strukturze: ins<0:7> := M[ea2]<0:7>; ins<8:15> := M[ea2]<8:15> or R[r1]<24:31>; next (ins<0:1> = 01 or 10) => ins<16:31> := M[ea2]<16:31>; (ins<0:1> = 11) => ins<16:47> := M[ea2]<16:47>

Rozkazy systemowe

Rozkazy systemowe manipulują słowem stanu PSW i pamięcią kluczy ochrony KM.

Tab. 1.13. IBM 360-370. Rozkazy systemowe

Oznaczenie

Kod

Format

Działanie

LPSW 82 SI PSW<0:63> M[ea1]<0:63>

SPM 04 RR PSW<34:39> M[ea1]<2:7>

SSM 80 SI PSW<0:7> M[ea1]<0:7>

SVC 0A RR PSW<16:23> 0; PSW<24:31> I2; next

M[32] PSW; next PSW M[96]<0:63>

SSK 08 RR KM[R[r3]<8:20>] R[r1]<24:28>

ISK 09 RR R[r1]<24:28> KM[R[r3]<8:20>]; next R[r1]<29:31> 0

TS 93 SI (M[ea1]<0>=0) => PSW<32:33> 0;

(M[ea1]<0>=1) => PSW<32:33> 1; next M[ea1]<0:7> #FF

- 83 SI Diagnoza

Rozkaz LPSW (Load PSW) ładuje słowo stanu z dowolnie wskazanego miejsca w pamięci i jest używany jako powrót z przerwania (ze stanu Supervisor do stanu Problem). Rozkaz LPSW jest rozkazem uprzywilejowanym podobnie jak rozkaz SSM ustawiający maskę systemową w PSW (maskowanie przerwań z poszczególnych kanałów we-wy i przerwań zewnętrznych).

Przejście od programu użytkownika do programu nadrzędnego, np. celem wywołania funkcji systemowych, odbywa się rozkazem SVC (SuperVisor Call).

Ustawienie i odczytanie dowolnego z 8192 kluczy ochrony (storage key) przypisanych do każdego 2048-bajtowego bloku pamięci operacyjnej umożliwiają rozkazy SSK (Set Storage Key) i ISK (Insert Storage Key).

Rozkaz TS (Test and Set) może być stosowany do synchronizacji współużytkowania tego samego obszaru pamięci przez kilka programów w systemie pracy wieloprogramowej.

Rozkaz o kodzie 83h nie ma mnemonika, gdyż jako rozkaz uprzywilejowany nie jest stosowany w programach użytkowych; wywołuje on operacje diagnostyczne sprawdzające poprawność działania sprzętu.

Rozkazy wejścia-wyjścia

Wszystkie rozkazy tej grupy są rozkazami uprzywilejowanymi, tzn. mogą być wykonywane tylko w stanie „Supervisor”, próba ich użycia w stanie „Problem” powoduje przerwanie programowe.


Tab. 1.14. IBM 360-370. Rozkazy wejścia-wyjścia

Oznaczenie

Kod

Format

Działanie

SIO 9C SI/S* Start I/O

TIO 9D SI/S* Test I/O

HIO 9E SI/S* Halt I/O

TCH 9F SI/S* Test CHannel

WRD 84 SI Bezpośrednie wyprowadzenie M[ea1]<0:7> na linie interfejsu

RDD 85 SI Bezpośrednie wprowadzenie danych z linii interfejsu do M[ea1]<0:7>

* Format SI w S/360, format S w S/370.

Rozkazy wejścia-wyjścia służą jedynie do zainicjowania pracy jednego z siedmiu tzw. kanałów wejścia-wyjścia. Kanały te są specjalizowanymi procesorami, realizującymi tzw. program kanałowy będący sekwencją komend kanałowych i same organizują transmisję bloku znaków między urządzeniem zewnętrznym a pamięcią. Do przeprowadzenia transmisji są potrzebne dane pobierane przez kanał z trzech źródeł:

rozkazu we-wy,

tzw. słowa adresowego kanału (CAW – channel address word),

komendy , czyli słowa sterującego (CCW – channel command word).

Np. rozkaz „start we-wy” (SIO) zawiera jedynie numer kanału, dla którego – zawsze pod stałym adresem bezwzględnym 72 - musi być przygotowane słowo adresowe wskazujące pierwszą komendę „programu kanałowego” umieszczonego w dowolnym miejscu pamięci. Dopiero komenda precyzuje operację transmisyjną (kierunek i sposób przesyłania) oraz zawiera adres i wielkość obszaru pamięci. 0 8 16 31 Rozkaz SIO (w programie)

Kod op. SIO Adres kanału i urządzenia

0 4 8 31 Słowo CAW (w pamięci, adres 72)

Klucz Adres pierwszej komendy kanałowej

Komenda CCW (w pamięci) 0 8 32 37 48 63

Typ operacji Adres początkowy

transmitowanego bloku Wskaźnik do ewentualnej następnej komendy

Długość transmitowanego bloku

Rys. 1.4. Etapy kompletowania informacji potrzebnej do transmisji kanałowej.

Dwa rozkazy transmisji bezpośredniej WRD i RDD przekazują pojedyncze bajty poprzez linie standardowego interfejsu i są stosowane tylko w szczególnych sytuacjach np. do komunikacji międzyprocesorowej.

Przerwania

System przerwań IBM 360-370 nie używa stosu a stan przerwanego programu zachowuje w ustalonych miejscach pamięci operacyjnej. W systemie wyróżnia się 5 klas przerwań:

przerwania wejścia-wyjścia (I/O),

przerwania programowe

wywołanie programu zarządzającego (SVC),

przerwania zewnętrzne (external),

przerwania kontroli maszyny (machine check).

Przerwania wejścia-wyjścia są powodowane przez zdarzenia powstające w kanałach lub jednostkach we-wy. Przerwania te mogą być maskowane osobno dla każdego kanału na pozycjach <0:6> PSW.


Przerwania programowe są generowane po wykryciu w programie specjalnych sytuacji takich, jak np. nadmiary arytmetyczne, dzielenie przez zero, niewłaściwy adres, próba wykonania rozkazu uprzywilejowanego itp. Spośród 16 różnych przerwań programowych można zamaskować cztery (PSW<36:39>).

Przerwanie wywołanie programu nadzorczego jest powodowane wykonywaniem rozkazu SVC („supervisor call”), który przełącza program ze stanu user do stanu supervisor. Przerwanie to jest umieszczone na tym samym poziomie priorytetu co przerwania programowe, gdyż przerwania w tych grupach wzajemnie się wykluczają.

Przerwania zewnętrzne są dokładnie definiowane dopiero dla konkretnej konfiguracji; są powodowane sygnałami z zegara systemowego, z panelu sterującego lub z innych procesorów w przypadku systemu wieloprocesorowego. Przerwania zewnętrzne mogą być maskowane bitem PSW<7>.

Najwyższy priorytet mają przerwania kontroli maszyny powodowane błędnym działaniem sprzętu. Program obsługi tych przerwań inicjuje z reguły procedurę diagnostyczną. Przerwania te mogą być maskowane bitem PSW<13>.

Dla każdej klasy są w pamięci zarezerwowane dwa słowa stanu nazywane „starym” (old) i „nowym” (new) PSW. Przerwanie w danej klasie zapamiętuje bieżące PSW jako stare a następnie pobiera nowe PSW i traktuje je jako bieżące.

Tab.1.15. Adresy starych i nowych słów stanu.

Rodzaj przerwania Stare PSW Nowe PSW

Wejścia-wyjścia 56 120

Programowe 40 104

Wywołanie programu zarządzającego 32 96

Zewnętrzne 24 88

Kontroli maszyny 48 112

Przed zapamiętaniem starego PSW na jego pozycje <16:31> jest wpisywany kod przerwania pozwalający programowi obsługi na precyzyjną identyfikację przyczyny i warunków przerwania.

Nowe PSW zawiera m.in. maski przerwań obowiązujące w czasie obsługi bieżącego przerwania oraz adres pierwszego rozkazu programu obsługi przyjętego przerwania umożliwiając jego inicjację. Z zasady programy obsługi są wykonywane w stanie supervisor dopuszczającym użycie rozkazów uprzywilejowanych. Powrót do przerwanego programu następuje rozkazem LPSW odtwarzającym słowo stanu ze swojej „przechowalni” starego PSW.


Small is beautiful. Ernst F. Schumacher

PDP-11 - minikomputer 16-bitowy

Historia

Nazwa PDP (Programmed Data Processor) była stosowana przez firmę Digital Equipment Corpopration na oznaczenie produkowanych przez nią komputerów od 1960 r., kiedy to powstał pierwszy, 18-bitowy PDP-1. Po wielkim sukcesie rynkowym kolejnego, tym razem 12-bitowego, PDP-8 – pierwszego minikomputera, w roku 1970 wprowadzono nową rodzinę PDP-11, która okazała się jedną z najbardziej wpływowych konstrukcji w historii maszyn cyfrowych. Twórcą architektury PDP-11 (podobnie jak PDP-8) był Gordon Bell. Produkowane później 32-bitowe komputery VAX-11 miały początkowo możność pracy w trybie zgodnym z PDP-11 i uważano je za kolejny etap ewolucji 16-bitowych PDP-11. Do roku 1990 wyprodukowano ponad 20 modeli tej maszyny konfigurowanej zarówno w postaci samodzielnych komputerów jak i w postaci procesorów przeznaczonych do wbudowania jako sterowniki większych systemów.

Oprócz wymienionych poniżej kilkunastu modeli, maszyny kompatybilne z PDP-11 były wytwarzane w latach 70. i 80. w Związku Radzieckim pod nazwą SM (СМ, Система миникомпютеров).

1970 /20, /15 Pierwsze dwa modele PDP-11, technologia małej skali scalania (SSI), sterowanie układowe, instalowano 8 lub 16 kB pamięci rdzeniowej (maksymalna wielkość - 56 kB).

1972 /45, /50 Wprowadzenie sterowania mikroprogramowego.

1973 /40, /35 Opcjonalne rozszerzenie listy rozkazów (EIS - operacje arytmetyczne i FIS - zmiennoprzecinkowe).

1975 /70 Zastosowanie pamięci cache, zewnętrzny adres 22-bitowy (4 MB pamięci), wydajność ponad 10x większa niż modelu /20

1975 LSI-11 Pierwszy mikrokomputer, 4 układy scalone wielkiej skali (LSI) zmontowane na jednej płycie (sinle-board computer).

1977 /60 Opcjonalny koprocesor zmiennoprzecinkowy, wydajność ok. 8x większa niż PDP-11/40 przy podobnej cenie, zapisywalna pamięć stała dla rozkazów definiowanych przez użytkownika.

1978 PDT 11/110, /130, /150

Programmable Data Terminal – bez urządzeń zewnętrznych, poprzednik współczesnych komputerów osobistych.

1979 /44 Wydajność zbliżona do /70 przy niższej cenie

1984 PRO-350, -325 Komputery osobiste (w tym czasie DEC opracował jeszcze dwie linie PC: procesor tekstowy bazujący na architekturze PDP-8 i Rainbow – na mikroprocesorach 8086/88).


1984 /73 Następca /44, zegar 15 MHz, cache.

1984 /83, /84 Ulepszone wersje /73, zegar 18 MHz, 8 kB cache, koprocesor zmp.

1990 /93, /94 Szybkie wersje /83, /84, zamiast oddzielnej pamięci cache - cała pamięć operacyjna (2 lub 4 MB) wykonana jako bardzo szybka, zintegrowany koprocesor zmp., zegar 18 MHz.

Procesor centralny

Procesor PDP-11 ma osiem 16-bitowych rejestrów uniwersalnych R1..R7 stosowanych zarówno do przechowywania argumentów operacji jak i do adresowania pamięci. Dwa z tych rejestrów, R6 i R7, pełnią specyficzne funkcje systemowe: R6 jest wskaźnikiem stosu (SP -Stack Pointer) a R7 jest licznikiem rozkazów (PC - Program Counter). Udostępnienie programiście SP i PC na tych samych zasadach co innych rejestrów rozszerza możliwości niektórych rozkazów a przede wszystkim daje specjalne efekty przy adresowaniu pamięci. Słowo stanu oznaczane PS (lub PSW - Processor Status Word) jest 16-bitowe i ma strukturę jak na rys. 2.1. Bity <15:8> są określone w niektórych późniejszych modelach PDP-11 (np. /40, /45, /70) gdzie służą m.in. do zarządzania rozszerzoną pamięcią. Bity <7:5> określają aktualny priorytet procesora; priorytet ten, ustawiany programowo, jest istotny np. przy obsłudze przerwań. Bit pracy krokowej T (Trace trap), jeżeli jest ustawiony na 1, powoduje przerwanie programowe po wykonaniu każdego rozkazu. Pozostałe bity PSW pełnią rolę znaczników stanu ustawiających się automatycznie po wykonaniu każdej operacji: N (negative) - wynik ujemny, Z (zero) - wynik zerowy, V (overflow) - nadmiar, C (carry) - przeniesienie z najbardziej znaczącej pozycji.

15 7 6 5 4 3 2 1 0

Priorytet CPU T N Z V C

Rys. 2.1. PDP-11. Słowo stanu PSW.

Standardowo pamięć PDP-11 ma pojemność 64 Kbajty

M[0:177777q]<7:0>

przy czym adresy 160000..177777 (ósemkowo) są rezerwowane dla urządzeń zewnętrznych (I/O). W tej przestrzeni wysokich adresów są umieszczone również rejestry wewnętrzne procesora (mają tam kolejne adresy, mimo, że są to rejestry 16-bitowe!), słowo stanu PSW i rejestr konsoli CS (Console Switch) służący do ręcznego sterowania komputerem np. przy inicjalizacji systemu (tab. 2.1). Adres wirtualny - generowany w programie lub pobierany z rejestrów procesora jest 16-bitowy, natomiast adres fizyczny - na magistrali systemowej jest 18-bitowy (w późniejszych modelach nawet 22-bitowy) umożliwiając rozbudowę pamięci do 256 Kbajtów (lub 4 MB) przez zainstalowanie specjalnego systemu zarządzania pamięci. Bez względu na wielkość dostępnej pamięci, ostatni blok o adresach wirtualnych 160000..177777 zawsze jest odwzorowany w obszarze fizycznym 760000..777777.

Tab. 2.1. PDP-11. Adresy rejestrów procesora

Rejestr

Adres (ósemkowo)

CS 177 570

R0 177 700

R1 177 701

R2 177 702

R3 177 703

R4 177 704

R5 177 705

R6 (SP) 177 706

R7 (PC) 177 707

PSW 177 776


Formaty danych Dane będące argumentami operacji są zapisywane na 8 lub 16 bitach. Adres słowa jest adresem mniej znaczącego (prawego) bajta (zasada Little-Endian):

Kolejność bitów 15 . . . 9 8 7 6 5 4 3 2 1 0

Adres a+1 a

Większość rozkazów ma dwie wersje – z argumentami bajtowymi i słowowymi, reprezentującymi liczby całkowite dwójkowe w kodzie uzupełnieniowym U2, liczby bez znaku lub łańcuchy binarne.

Niektóre modele rodziny PDP 11 z listą rozkazów rozszerzoną o operacje zmiennopozycyjne (Floating Point Arithmetic) mogą działać na liczbach zmiennopozycyjnych znormalizowanych, kodowanych na 32 lub 64 bitach (single i double precision) w następującym formacie:

s e f

1 8 23/55 W przedstawieniu znormalizowanej mantysy zastosowano tzw. „bit ukryty”, dzięki czemu jej efektywna długość wynosi odpowiednio 24 lub 56 bitów. Wartość takiej liczby oblicza się wg formuły

(-1)s 2

e-128 0,1f

Zero jest kodowane jako łańcuch samych zer.

Kodowanie rozkazów

Rozkazy w PDP-11 są kodowane w jednym, dwóch lub trzech słowach 16-bitowych. Pierwsze słowo zawiera kod operacji i określenie argumentów, ewentualne dodatkowe słowa zawierają argument bezpośredni lub składowe jego adresu.

Struktura słowa rozkazowego zależy od liczby argumentów. Dwa podstawowe formaty przedstawia rys. 2.2, jest tam również pokazany specjalny format dla rozkazów skoków względnych (branch). Rozkazy bezargumentowe (z argumentem domyślnym) - przeznaczają całe słowo na kod operacji. Specyficzne formaty mają dwa rozkazy – JSR oraz RTS, w których jeden argument może być tylko argumentem rejestrowym. Kodowanie wszystkich rozkazów przedstawiono dokładnie w tablicach 2.5 - 2.10 zawierających podstawową listę rozkazów PDP-11.

W słowie rozkazowym argument jest wskazywany przez 6-bitowe pole nazywane dalej src lub dst; 3 bity tego pola oznaczają sposób adresacji (m - mode) a pozostałe 3 określają numer rejestru (n) stosowanego do wyznaczenia adresu efektywnego (EA) argumentu w pamięci. Do adresacji można stosować wszystkie 8 rejestrów R0..R7, jednak użycie rejestru R7=PC powoduje specjalne efekty i jest wyróżnione w języku asemblera osobnym zapisem symbolicznym. Jeden ze sposobów adresacji (m=0) umożliwia wskazywanie argumentu bezpośrednio w rejestrze.


15 11 5 0

a) Kod op. src dst

15 5 0

b) Kod op. dst

15 7 0

c) Kod op. offset

15 0

d) Kod op.

15 3 2 0

e) Kod op. Rn

15 9 8 6 5 3 2 0

f) Rn dst

Rys. 2.2. PDP-11. Formaty rozkazów a) dwuargumentowych, b) jednoargumentowych, c) skoków względnych, d) bezadresowych,

e) rozkazu RTS, f) rozkazu JSR.

Wszystkie sposoby adresacji, wraz z ich oznaczeniami asemblerowymi, przedstawiono w tablicach 2.2 i 2.3; występująca tam wartość licznika rozkazów PC jest aktualizowana zawsze po pobraniu kolejnego słowa (początkowo PC wskazuje adres następny za pierwszym słowem rozkazu).

Tab. 2.2. PDP 11. Podstawowe sposoby adresacji.

m Oznaczenie asemblerowe

Obliczenie adresu efektywnego

0 Rn (Argument w rejestrze Rn)

1 (Rn) EA Rn

2 (Rn)+ EA Rn; next Rn Rn+2-b

3 @(Rn)+ EA M[Rn]; next Rn Rn+2

4 -(Rn) Rn Rn-2+b; next EA Rn

5 @-(Rn) Rn Rn-2+b; next EA M[Rn]

6 dsp(Rn) dsp M[PC]; next PC PC+2; next EA Rn+dsp

7 @dsp(Rn) dsp M[PC]; next PC PC+2; next EA M[Rn+dsp]

UWAGA: b=0 dla argumentów słowowych, b=1 dla argumentów bajtowych.

Rozkazy z adresacją m=0 (rejestrowa), m=1 (rejestrowa pośrednia), m=2 (autoinkrementowa), m=3 (autoinkrementowa pośrednia), m=4 (autodekrementowa) i m=5 (autodekrementowa pośrednia) są jednosłowowe.

Tab. 2.3. PDP 11. Sposoby adresacji z PC (n = 7)

m Oznaczenie asemblerowe

Obliczenie adresu efektywnego

2 #data EA PC; next PC PC+2

3 @#addr EA M[PC]; next PC PC+2

6 addr X M[PC]; next PC PC+2; next EA PC+X

7 @addr X M[PC]; next PC PC+2; next EA M[PC+X]

Stosowanie adresacji m=6 (indeksowa), m=7 (indeksowa pośrednia) lub którejkolwiek z n=7 (natychmiastowa, absolutna, względna i względna pośrednia) powoduje wydłużenie rozkazu o jedno


słowo. Program asemblujący umieszcza w tym dodatkowym słowie (M[PC]) parametr odpowiedni dla danego sposobu adresacji. W ten sposób, w rozkazach 2-argumentowych, oprócz słowa zawierającego kod rozkazu, mogą występować aż dwa dodatkowe słowa.

Działanie asemblera przy obliczaniu kolejnego słowa rozkazu pokazano w tab. 2.4.

Tab. 2.4. PDP-11. Działanie asemblera przy dekodowaniu argumentów rozkazu

Sposób adresacji

Działanie asemblera

dsp(Rn) M[PC] dsp

@dsp(Rn) M[PC] dsp

#data M[PC] data

@#addr M[PC] addr

Addr M[PC] addr-(PC+2)

@addr M[PC] addr-(PC+2)

dsp, data - liczby 16-bitowe ze znakiem (-32768..+32767), addr - liczba 16-bitowa dodatnia (0..65535).

Np. jeżeli rozkaz

CMP #101, PRB

jest umieszczony pod adresem 2406q, a adres PRB = 177642q, to rozkaz ten w pamięci będzie kodowany jak pokazuje rys. 2.3.

Kod „CMP” src dst Adresy

0 2 2 7 6 7 2406

101 = 0 0 0 1 0 1 2410

177642-2414 = 1 7 5 2 2 6 2412

2414

Rys. 2.3. PDP-11. Przykład kodowania rozkazu CMP (postać ósemkowa)

Osobny sposób kodowania adresu jest przewidziany dla rozkazów skoków względnych (branch). Odległość skoku w stosunku do bieżącego (dokładnie: do następnego) rozkazu jest liczona w słowach i wpisywana w 8-bitowym polu offset rozkazu. Asembler przesłania tę strukturę rozkazu, gdyż składnia rozkazów branch jest taka sama jak rozkazów jednoargumentowych z m=6 i n=7:

BR addr.

Program asemblujący wylicza wartość offset wg formuły:

offset = (addr - (PC + 2))/2

gdzie PC oznacza adres bieżącego rozkazu.

Na rys. 2.4 pokazano przykład kodowania dwóch rozkazów spełniających tę samą funkcję: „JMP ALEF” i „BR ALEF”; założono, że w obu przypadkach PC=2060q a ALEF=2220q. Rozkaz JMP tu jest dwusłowowy (m=6, n=7) natomiast rozkaz BR mieści się w jednym słowie.


Kod „JMP” dst JMP dst Adresy

0 0 0 0 0 0 0 0 0 1 1 1 0 1 1 1 0 0 0 1 6 7 2060

0 0 0 0 0 0 0 0 0 1 0 1 1 1 0 0 0 0 0 1 3 4 2062

addr = 2220-2064 = 134 addr

(a) Rozkaz JMP ALEF

Kod „BR” offset BR offset Adresy

0 0 0 0 0 0 0 1 0 0 1 0 1 1 1 1 0 0 0 4 5 7 2060

offset = (2220-2062)/2 = 57

(b) Rozkaz BR ALEF

Rys. 2.4. PDP-11. Przykład kodowania rozkazów JMP (a) i BR (b) - postać dwójkowa i ósemkowa.

Lista rozkazów

Wszystkie podstawowe rozkazy PDP-11 przedstawiono dokładnie w tablicach 2.5 - 2.10. Niektóre późniejsze modele rodziny PDP-11 miały tę listę rozszerzoną o grupę rozkazów stałopozycyjnych, tzw. EIS (Extended Instruction Set - mnożenie, dzielenie, długie przesunięcia) i grupę rozkazów zmiennopozycyjnych, tzw. FIS (Floating-point Instruction Set - cztery działania arytmetyczne na liczbach kodowanych zmiennoprzecinkowo).

Przy opisie rozkazów zastosowano następujące oznaczenia:

src - 6-bitowe pole kodu argumentu źródłowego dst - 6-bitowe pole kodu argumentu docelowego r - 3-bitowe pole kodu rejestru, numer rejestru (0..7) offset - 8-bitowe pole adresu względnego, liczba (-128..+127) EA - adres efektywny obliczony wg pola src lub dst SRC - argument źródłowy obliczony wg pola src (Rn lub M[EA]) DST - argument docelowy obliczony wg pola dst (Rn lub M[EA]).

Każdy rozkaz opisano podając jego oznaczenie w języku asemblera, postać dwójkową słowa rozkazowego i zapis działania w notacji ISP. W opisie rozkazów pominięto, z kilkoma wyjątkami, sposób ustawiania znaczników N, Z, V i C umieszczonych w słowie stanu PSW.

Jeżeli rozkaz ma wersję bajtową i słowową - podano obydwa rozkazy, zaznaczając rozmiar argumentu tylko w rozkazach bajtowych (<7:0>), w pozostałych przypadkach zakłada się domyślny format <15:0>. Całą listę rozkazów podzielono na 5 grup:

rozkazy przesłań

rozkazy arytmetyczne

rozkazy logiczne

rozkazy sterujące (skoki)

rozkazy systemowe.

Rozkazy przesłań

PDP-11 ma jeden uniwersalny rozkaz przesłania danych - MOV (MOVB). Rozkaz ten, zależnie od doboru argumentów i sposobu adresowania, spełnia funkcje tradycyjnie wykonywane w innych komputerach przez rozkazy takie jak np. load i store (do komunikacji rejestrów z pamięcią), push i pop (do działań na stosie) czy in i out (do operacji wejścia-wyjścia).

Tab. 2.5. PDP-11. Rozkazy przesłań

Oznaczenie

Kod

Działanie

MOV 0 001 src dst DST SRC

MOVB 1 001 src dst DST<7:0> SRC<7:0>


Rozkazy wejścia-wyjścia, dla których nie ma osobnych kodów, są możliwe do wykonania przez MOV dzięki temu, że przyjęto umieszczanie wszystkich rejestrów urządzeń zewnętrznych we wspólnej przestrzeni adresowej z pamięcią operacyjną (memory mapped I/O).

W tab. 2.6 zestawiono przykłady zastosowania rozkazu MOV (MOVB); zmienna ADRS oznacza komórkę pamięci, zmienne BUFIN i BUFOUT oznaczają rejestr wejściowy i wyjściowy urządzenia zewnętrznego.,

Tab. 2.6. PDP-11. Przykłady zastosowań rozkazu MOV

Rozkaz PDP 11

Funkcja

Odpowiednik

MOV R1, R2 Przesłanie międzyrejestrowe Move MOV R1, ADRS Zapamiętanie rejestru w pamięci Store MOV ADRS, R1 Załadowanie rejestru z pamięci Load MOV #DATA, R1 Wpisanie stałej Load immediate MOV R1, -(SP) Zapisanie na stos Push

MOV (SP)+, R1 Odczytanie ze stosu Pop MOV BUFIN, R1 Czytanie danych wejściowych In MOV R1, BUFOUT Pisanie danych wyjściowych Out

Rozkazy arytmetyczne

Rozkazy arytmetyczne (tab. 2.7) bezpośrednio realizują tylko trzy działania na liczbach w kodzie uzupełnieniowym: dodawanie (ADD), odejmowanie (SUB) i zmianę znaku (NEG). Do działań ze zwiększoną dokładnością można stosować rozkazy ADC i SBC, które w przeciwieństwie do wielu innych maszyn, są jednoargumentowe, co nieco wydłuża odpowiednie programy.

Tab. 2.7. PDP-11. Rozkazy arytmetyczne

Oznaczenie

Kod

Działanie

ADD 0 110 src dst DST SRC+DST SUB 1 110 src dst DST DST-SRC ADC 0 000 101 101 dst DST DST+C ADCB 1 000 101 101 dst DST<7:0> DST<7:0>+C SBC 0 000 101 110 dst DST DST-C SBCB 1 000 101 110 dst DST<7:0> DST<7:0>-C NEG 0 000 101 100 dst DST 0-DST NEGB 1 000 101 100 dst DST<7:0> 0-DST<7:0> CMP 0 010 src dst SRC-DST; (N,Z,V,C) CMPB 1 010 src dst SRC<7:0> -DST<7:0>; (N,Z,V,C) INC 0 000 101 010 dst DST DST+1 INCB 1 000 101 010 dst DST<7:0> DST<7:0>+1 DEC 0 000 101 011 dst DST DST-1 DECB 1 000 101 011 dst DST<7:0> DST<7:0>-1 TST 0 000 101 111 dst Z (DST=0); N DST<15>; C 0; V 0 TSTB 1 000 101 111 dst Z (DST=0); N DST<7>; C 0; V 0

Rozkaz porównania arytmetycznego (CMP) ustawiający znaczniki według cech wyniku odejmowania SRC - DST (kolejność argumentów jest tu odwrotna niż w rozkazie SUB!) bywa najczęściej stosowany przed rozkazami skoków warunkowych. Nazwy tych skoków odnoszą się właśnie do wyniku takiego porównania; np. BPL – "(wynik) dodatni", BEQ – "równy (zeru)" itp.

Rozkazy INC i DEC traktują argument jako liczbę całkowitą bez znaku a dodawanie lub odejmowanie jedynki odbywa się mod 65536.


Rozkazy logiczne

W grupie rozkazów logicznych ( tab. 2.8 ) są działania boolowskie na argumentach traktowanych jako łańcuchy zerojedynkowe oraz rozkazy przesunięć.

Rozkaz porównania logicznego (BIT lub BITB) oblicza iloczyn logiczny argumentów i na tej podstawie ustawia znaczniki N i Z bez zapisywania wyniku. Rozkaz uzupełnienia (COM lub COMB) oblicza uzupełnienie jedynkowe (U1, negacja logiczna) argumentu – w przeciwieństwie do rozkazu arytmetycznego NEG dającego uzupełnienie dwójkowe (U2).

Operacje przesunięć są 1-pozycyjne, przy czym przesunięcia cykliczne zawsze dotyczą argumentu (8- lub 16-bitowego) wydłużonego o pozycję znacznika C.

Rozkazy zerowania i ustawiania znaczników (CL_ i SE_) są kodowane mikroprogramowo: jedynki na pozycjach <3:0> wskazują znacznik N, Z, V lub/i C, natomiast wartość pozycji <4> określa czy wskazane znaczniki mają być zerowane (0), czy ustawiane (1). Np. rozkaz jednoczesnego zerowania znaczników V i C ma kod 0 000 000 010 100 011. Nie wskazanie żadnego znacznika jest równoważne rozkazowi „nic nie rób” NOP.

Tab. 2.8. PDP-11. Rozkazy logiczne

Oznaczenie

Kod

Działanie

BIT 0 011 src dst SRC and DST ; (N,Z) BITB 1 011 src dst SRC<7:0> and DST<7:0> ; (N,Z) BIC 0 100 src dst DST (not SRC) and DST BICB 1 100 src dst DST<7:0> (not SRC<7:0>) and DST<7:0> BIS 0 101 src dst DST SRC or DST BISB 1 101 src dst DST<7:0> SRC<7:0> or DST<7:0> COM 0 000 101 001 dst DST not DST COMB 1 000 101 001 dst DST<7:0> not DST<7:0> CLR 0 000 101 000 dst DST 0 CLRB 1 000 101 000 dst DST<7:0> 0 ROR 0 000 110 000 dst C^DST ror (C^DST) RORB 1 000 110 000 dst C^DST<7:0> ror (C^DST<7:0>) ROL 0 000 110 001 dst C^DST rol (C^DST) ROLB 1 000 110 001 dst C^DST<7:0> rol (C^DST<7:0>) ASR 0 000 110 010 dst DST shra DST ASRB 1 000 110 010 dst DST<7:0> shra DST<7:0> ASL 0 000 110 011 dst DST shl DST ASLB 1 000 110 011 dst DST<7:0> shl DST<7:0> SWAB 0 000 000 011 dst DST<15:8> DST<7:0> CLC 0 000 000 010 100 001 C 0 CLV 0 000 000 010 100 010 V 0 CLZ 0 000 000 010 100 100 Z 0 CLN 0 000 000 010 101 000 N 0 CCC 0 000 000 010 101 111 N^Z^V^C 0000 SEC 0 000 000 010 110 001 C 1 SEV 0 000 000 010 110 010 V 1 SEZ 0 000 000 010 110 100 Z 1 SEN 0 000 000 010 111 000 N 1 SCC 0 000 000 010 111 111 N^Z^V^C 1111

Rozkazy sterujące

Wśród rozkazów sterujących program (tab. 2.9 ) jest jeden rozkaz bezwarunkowego skoku bezwzględnego (JMP) i 14 rozkazów warunkowych skoków względnych. Skoki względne są jednosłowowe i mają zasięg od -128 do +127 słów w stosunku do bieżącego rozkazu.


Tab. 2.9. PDP-11. Rozkazy sterujące

Oznaczenie

Kod

Działanie

JMP 0 000 000 001 dst PC EA JSR 0 000 100 r dst SP SP-2; next M[SP] Rr; next Rr PC;

next PC EA RTS 0 000 000 010 000 r PC Rr; next Rr M[SP]; next SP SP+2 BR 0 000 000 1 offset PC PC+2*offset BNE 0 000 001 0 offset (Z=0) => PC PC+2*offset BEQ 0 000 001 1 offset (Z=1) => PC PC+2*offset BPL 1 000 000 0 offset (N=0) => PC PC+2*offset BMI 1 000 000 1 offset (N=1) => PC PC+2*offset BVC 1 000 010 0 offset (V=0) => PC PC+2*offset BVS 1 000 010 1 offset (V=1) => PC PC+2*offset BCC (BHIS) 1 000 011 0 offset (C=0) => PC PC+2*offset BCS (BLO) 1 000 011 1 offset (C=1) => PC PC+2*offset BGE 0 000 010 0 offset ((NxorV)=0) => PC PC+2*offset BLT 0 000 010 1 offset ((NxorV)=1) => PC PC+2*offset BGT 1 000 011 0 offset (Zor((NxorV)=0)) => PC PC+2*offset BLE 1 000 011 1 offset (Zor((NxorV)=1)) => PC PC+2*offset BHI 1 000 001 0 offset ((CorZ)=0) => PC PC+2*offset BLOS 1 000 001 1 offset ((CorZ)=1) => PC PC+2*offset

Oryginalną konstrukcję ma skok do podprogramu (JSR): adres powrotu (aktualna zawartość PC) jest przechowywany w dowolnym rejestrze uniwersalnym r wskazanym w rozkazie; poprzednia zawartość tego rejestru jest przenoszona na stos. Jeżeli zastosować najczęściej używaną formę tego rozkazu z rejestrem łącznikowym r = PC, czyli

JSR PC,ADRES wówczas skok do podprogramu wykonuje się konwencjonalnie, tak jak np. w większości mikrokomputerów. Skok w postaci

JSR PC,@(SP)+ umożliwia tworzenie tzw. współprogramów (coroutines) - wejście do współprogramu nie wymaga podania w rozkazie etykiety, gdyż sterowanie jest przenoszone do miejsca, z którego było ostatnie wyjście tym specyficznym rozkazem (adres EA podprogramu jest na wstępie pobierany ze stosu a dopiero później na stos jest przesyłany PC).

Rozkaz RTS działa odwrotnie do JSR umożliwiając powrót z podprogramu.

Rozkazy systemowe

Pozostałe rozkazy (tab. 2.10) są stosowane głównie w oprogramowaniu systemowym komputera. Rozkaz HALT zatrzymuje pracę maszyny tak, że ponowne uruchomienie wymaga ręcznego działania operatora. Rozkaz WAIT powoduje przejście w stan oczekiwania, w którym nie są wykonywane żadne rozkazy, natomiast są przyjmowane przerwania.

Rozkazy "pułapek" (traps) TRAP, EMT, BPT, IOT są w istocie programowanymi przerwaniami z wektorami odpowiednio 34q, 30q, 14q i 20q. Rozkaz RTI powoduje powrót z przerwania polegający na odtworzeniu zawartości licznika rozkazów i słowa stanu.

Rozkaz RESET generuje sygnał zerujący wszystkie moduły komputera dołączone do magistrali systemowej UNIBUS.


Tab. 2.10. PDP-11. Rozkazy systemowe

Oznaczenie

Kod

Działanie

NOP 0 000 000 010 100 000 {Brak działania} HALT 0 000 000 000 000 000 {Stop} WAIT 0 000 000 000 000 001 {Oczekiwanie na INTR} RESET 0 000 000 000 000 101 {Zerowanie modułów zewnętrznych} RTI 0 000 000 000 000 010 PC M[SP]; next SP SP+2; next PSW M[SP];

next SP SP+2 EMT 1 000 100 0xx xxx xxx SP SP-2; next M[SP] PSW; next SP SP-2;

M[SP] PC; next PC M[30]; PSW M[32] TRAP 1 000 100 1xx xxx xxx SP SP-2; next M[SP] PSW; next SP SP-2;

M[SP] PC; next PC M[34]; PSW M[36] BPT 0 000 000 000 000 011 SP SP-2; next M[SP] PSW; next SP SP-2;

M[SP] PC; next PC M[14]; PSW M[16] IOT 0 000 000 0000 000 100 SP SP-2; next M[SP] PSW; next SP SP-2;

M[SP] PC; next PC M[20]; PSW M[22]

Przerwania

Przerwania w PDP-11 dzielą się na zewnętrzne (interrupts) i wewnętrzne zwane pułapkami (traps). Pułapki są powodowane przez zdarzenia wewnątrz komputera, takie jak zanik zasilania, zakończenie cyklu rozkazowego przy ustawionym znaczniku T w słowie stanu lub zdekodowanie rozkazu pułapki.

Przerwania zewnętrzne są powodowane przez sygnał INTR pojawiający się na magistrali systemowej UNIBUS; źródłem tego sygnału może być dowolny moduł komputera. Priorytet przerwania zależy od poziomu, na jakim przerwanie zostało zgłoszone. Poziom ten jest dla modułów komputera ustalany instalacyjnie przez wybór jednej z linii magistrali systemowej: BR7, BR6, BR5 lub BR4. Warunkiem przyjęcia przerwania jest, aby numer poziomu był większy niż aktualny priorytet procesora określony przez pozycje <7:5> słowa stanu PSW. W obrębie jednego poziomu obowiązuje "priorytet geometryczny": moduł bliższy procesora ma wyższy priorytet.

Jeżeli zgłoszenie przerwania zostanie przyjęte, to następuje przełączenie programów:

bieżące PSW i PC jest składowane na stosie systemowym (wg aktualnej wartości SP)

nowe wartości PC i PSW są pobierane z "wektora" danego przerwania określonego przez bity <7:2> szyny danych

rozpoczyna się program obsługi przerwania (program ten powinien być zakończony rozkazem powrotu do przerwanego programu RTI).

Działania te, wykonywane automatycznie odpowiadają następującej sekwencji rozkazów:

MOV PSW, -(SP)

MOV PC, -(SP)

MOV VEC, PC ;VEC - AKTUALNY ADRES WEKTORA

MOV VEC+2, PSW

Wektory przerwań muszą być umieszczone w początkowym obszarze pamięci (adresy 000000q..000377q) i może ich być 64. Każdy wektor ma adres podzielny przez 4 i zawiera dwa słowa: adres początkowy programu obsługi (nowe PC) i priorytet programu obsługi (nowe PSW). Np. przygotowanie wektora dla przerwania 48 (adres 300q), którego program obsługi umieszczony jest pod adresem PRGOB i ma mieć po uruchomieniu priorytet 4 (zgłoszenie na poziomie BR4) odbywa się dwoma rozkazami:

MOV #PRGOB, @#300 ;ADRES POCZATOWY PROGRAMU

MOV #200, @#302 ;PRIORYTET=4, T=N=Z=V=C=0


Każde źródło przerwania musi oprócz sygnału INTR generować swój 5-bitowy numer podawany na pozycjach <7:2> szyny danych; pełnych 8 bitów <7:0> wyznacza adres wektora.

Z opisanego mechanizmu przyjmowania przerwań wynika, że przerwania mogą być zagnieżdżane na głębokość ograniczoną jedynie wielkością stosu. Ochrona programów przed przerwaniami jest możliwa przez dobór priorytetu procesora w czasie wykonywania danego programu.


Embarras de richese.

Leonor J. d’Allainval.

VAX - superminikomputer

Historia

Procesory VAX zostały zaprojektowane jako kontynuacja rodziny minikomputerów PDP-11; pierwsze modele nowej rodziny oznaczano VAX-11, a sam skrót odnosi się do słynnego poprzednika wskazując na istotną zmianę w architekturze: Virtual Address Extension. Architektura VAX (szefem zespołu, w którym uczestniczył m.in. Gordon Bell był William Strecker) jest uważana za szczytowe osiągnięcie w realizacji koncepcji CISC (complex instruction-set computers) - rozkazy języka wewnętrznego ( i ich odpowiedniki asemblerowe) osiągają możliwości dostępne zwykle w językach wysokiego poziomu.

Architektura VAX była implementowana w komputerach firmy Digital Equipnent Corp. (DEC) od połowy lat 70. przez dwie dekady, aż do wprowadzenia architektury Alpha. Można wyróżnić kolejne serie tych komputerów:

Seria 700 (od roku 1977) - modele VAX-11/780, VAX-11/750, VAX-11/730,

MicroVAX I (1984),

Seria 8000 (od roku 1986),

MicroVAX II (od 1985),

Seria 3x00 (1986 - 1991),

Seria 4x00 (1991 - 1995?).

Modele w poszczególnych seriach różnią się wydajnością, organizacją logiczną i technologią. Jako pierwszy w technologii mikroprocesorowej został zrealizowany MicroVAX (VAX 78032), przy czym tylko 175 spośród 304 rozkazów i tylko 6 z 14 możliwych typów danych implementowano w postaci mikrokodu; reszta była emulowana. Mimo tych ograniczeń, wymuszonych koniecznością uproszczenia układu scalonego, ten podzbiór rozkazów obsługiwał ok. 98% rozkazów wykonywanych przez typowe programy. Te wyniki były jednym z argumentów za wprowadzeniem architektury RISC.

Szybkość poszczególnych maszyn, mierzona w stosunku do VAX-11/780, wynosi od 0,3 (wczesny model VAX-11/730 z lat 70.) do 120 i 250 w modelach VAX 7000 z początku lat 90. VAX-11/780 był taktowany zegarem 5MHz, MicroVAX 3100 - zależnie od modelu - od 25 do 83 MHz, a np. VAX 7000 miał zegar 91 MHz.

Wydajność VAX-11/780 została przyjęta jako punkt odniesienia do pomiarów wydajności komputerów za pomocą programów wzorcowych (benchmarks) wg standardu SPEC89.

Rejestry procesora

Stan procesora jest określony przez

rejestry uniwersalne R0..R15,

rejestry wewnętrzne procesora (IPR - Privileged Internal Procesor Registers),

podwójne słowo stanu (PSL - Processor Status Longword),

Rejestry uniwersalne są 32-bitowe i służą do przechowywania argumentów operacji a ponadto są stosowane we wszystkich sposobach adresowania argumentów umieszczonych w pamięci. Rejestry R12..R15 mają określone funkcje systemowe.

Rejestr R15 oznaczany też PC (Program Counter) jest licznikiem rozkazów i przechowuje zawsze adres następnego rozkazu; PC jest bazą adresacji względnej (PC + displ).

Rejestr R14 oznaczany SP (Stack Pointer) jest wskaźnikiem stosu i zawiera adres jego wierzchołka.


Rejestry R12 (AP - Argument Pointer) i R13 (FP - Frame Pointer) są wskaźnikami struktur danych stosowanych przy wywoływaniu procedur (rozkazy CALLG i CALLS).

Niektóre rozkazy stosują rejestry R0..R5 jako domyślne miejsca przechowywania wyników (np. rozkazy działające na łańcuchach znaków, rozkazy POLY_).

Rejestry wewnętrzne procesora (IPR) stanowią grupę ponad 30 rejestrów 32-bitowych zawierających informacje sterujące i statusowe dotyczące np. systemu zarządzania pamiecią, stosów istniejących na wszystkich poziomach dostępu itp. Rejestry te mają swoje adresy (numery) z zakresu 0..63 i są dostępne programowo uprzywilejowanymi rozkazami MTPR i MFPR (tylko w trybie Kernel).

Podwójne słowo stanu (PSL - Processor Status Longword) zawiera podstawowe informacje o stanie procesora (rys. ). Pole <15:0> noszące nazwę PSW (Processor Status Word) przechowuje znaczniki warunków modyfikowane po każdym rozkazie i bity maskujące niektóre sytuacje wyjątkowe. PSW może być modyfikowane programowo rozkazami BICPSW i BISPSW. Całe PSL można jedynie przesyłać rozkazem MOVPSL.

15 14 13 12 11 10 9 8 7 6 5 4 3 2 1 0

0 0 0 0 0 0 0 0 DV FU IV T N Z V C

31 30 29 28 27 26 25 24 23 22 21 20 19 18 17 16

CM TP 0 0 FPD IS CUR_M PRV_M 0 IPL

Rys. 3.1. VAX. Podwójne słowo stanu (PSL)

Poszczególne pola PSL mają następujące znaczenie:

N,Z,V,C - znaczniki odpowiednio wyniku ujemnego, wyniku zerowego, nadmiaru i przeniesienia,

T - gdy = 1, powoduje przerwanie po każdym rozkazie,

DV,FU,IV - gdy = 0, maskuje przerwania przy wystąpieniu odpowiednio, nadmiaru dziesiętnego, niedomiaru zmp. i nadmiaru stp.,

IPL - priorytet (przyjmowane są tylko przerwania o priorytecie większym),

PRV_M - poprzedni tryb dostępu:

00 - Kernel,

01 - Executive,

10 - Supervisor,

11 - User

CUR_M - tryb dostępu aktualnie działającego procesu (kodowanie - jak w PRV_M),

IS - gdy = 1, procesor działa ze stosem przerwań (w trybie Kernel), - gdy = 0, procesor działa ze stosem określonym przez CUR_MOD,

FPD - gdy = 1, rozkaz określony przez PC nie może być wykonywany od początku (np. był przerwany po wykonaniu fragmentu),

TP - ustawiane przez procesor na początku rozkazu, jeżeli T=1,

CM - gdy = 1, praca w sposób zgodny (kompatybilny) z PDP-11.

D - gdy = 1, rozkaz określony przez PC nie może być wykonywany,

Słowo rozkazowe

Struktura rozkazu

Rozkazy VAX są różnej długości, zależnej od wykonywanej operacji, liczby argumentów, typu tych argumentów i sposobu adresowania. Kod operacyjny zapisany w pierwszym bajcie rozkazu (w niektórych przypadkach na 2 bajtach) określa tylko liczbę specyfikatorów, które wystąpią w rozkazie, natomiast ich wielkość zleży od sposobu adresowania.

Np. rozkaz INCW (inkrementuj słowo) ma jeden specyfikator - adres słowa, które ma być zwiększone o 1, rozkaz MOVL (prześlij długie słowo) ma dwa specyfikatory będące adresami źródłowym i docelowym przesłania, natomiast rozkaz MOVC5 (kopiuj łańcuch znaków wypełniając ewentualne wolne miejsca) ma 5 specyfikatorów: długość i adres łańcucha źródłowego, postać bajta wypełniacza, długość i adres łańcucha docelowego.


Na ogół każdy specyfikator może być kodowany według dowolnego (sensownego w danym kontekście) sposobu adresacji - niezależnie od sposobu kodowania innych specyfikatorów danego rozkazu.

Adresowanie argumentów

Sposób adresacji każdego argumentu jest kodowany na 8 bitach: 4 bity (m) określają tryb adresacji a pozostałe 4 bity (r) wskazują jeden z 16 rejestrów (R0..R15) związany z adresacją.

7 6 5 4 3 2 1 0

m r

Rys. 3.2. VAX. Pole kodu adresacji.

Adresacja natychmiastowa krótka (literal); m= 0-3 Argumentem jest 6 bitów bajta adresowego <5:0>, łącznie z polem r. Pole m ma wartość określoną przez bity <5:4> (0, 1, 2 lub 3).

7 6 5 4 3 2 1 0

0 0 Argument

Rys.3. 3. VAX. Argument natychmiastowy krótki.

Adresacja rejestrowa (register); m=5. Argumentem jest rejestr R[r]..

Adresacja pośrednia rejestrowa (register deferred); m=6. Argumentem jest zawartość pamięci adresowana przez rejestr R[r].

Adresacja autodekrementowa (autodecrement); m=7. Argumentem jest zawartość pamięci adresowana przez rejestr R[r]. Przed obliczeniem adresu zawartość R[r] jest zmniejszana o liczbę równą długości argumentu wyrażoną w bajtach.

Adresacja autoinkrementowa (autoincrement); m=8. Argumentem jest zawartość pamięci adresowana przez rejestr R[r]. Po obliczeniu adresu zawartość R[r] jest zwiększana o liczbę równą długości argumentu wyrażoną w bajtach.

Adresacja pośrednia autoinkrementowa (autoincrement deferred); m=9. Adresem podwójne słowo wskazywane przez rejestr R[r]. Po obliczeniu adresu zawartość R[r] jest zwiększana o 4.

Adresacja przesunięta (byte-, word-, longword displacement); m=A, C lub E. Adresem jest zawartość rejestru R[r] zwiększona o przesunięcie (displacement) umieszczone w rozkazie za polem adresowym. Przesunięcie jest traktowane jako liczba ze znakiem w kodzie uzupełnieniowym.

Adresacja przesunięta pośrednia (byte-, word-, longword displacement deferred); m=B, D lub F. Adresem jest podwójne słowo w pamięci wskazane przez zawartość rejestru R[r] zwiększoną o przesunięcie (displacement) umieszczone w rozkazie za polem kodu adresacji. Przesunięcie jest traktowane jako liczba ze znakiem w kodzie uzupełnieniowym.

Indeksacja. Adresy wyznaczone w trybach od m=6 do m=F mogą być indeksowane jeżeli przed głównym kodem adresacji występuje dodatkowe pole kodu adresacji z trybem m=4. Wskazany w tym polu rejestr zawiera indeks, który po pomnożeniu przez długość argumentu jest dodawany do adresu obliczonego na podstawie głównego kodu adresacji.

Adresacja względem licznika rozkazów. Jeżeli pole r = F, wówczas rejestrem adresowym jest R15, czyli licznik rozkazów (PC). W efekcie tryby od m=8 do m=F uzyskują nowe znaczenie uwidocznione na poziomie asemblera nowymi nazwami i nową składnią:

Adresacja natychmiastowa (immediate); r=F i m=8. Argument znajduje sie w rozkazie za polem kodu adresacji.

Adresacja bezwzględna (absolute); r=F i m=9. Pełny 32-bitowy adres argumentu znajduje się w rozkazie za polem kodu adresacji.


Adresacja względna (byte-, word-, longword relative); r=F i m=A, C lub E. W rozkazie jest adres względny argumentu podany na 8, 16 lub 32 bitach jako liczba w kodzie uzupełnieniowym.

Adresacja względna pośrednia (byte-, word-, longword relative deferred); r=F i m=B, D lub F. W rozkazie jest adres względny argumentu podany na 8, 16 lub 32 bitach jako liczba w kodzie uzupełnieniowym.

Tab.3.1. VAX. Oznaczenia asemblerowe argumentów.

Nazwa

Oznaczenie

m

r

Literal S^#const 0-3

Indexed [Rx] 4

Register Rn 5

Register deferred (Rn) 6

Autodecrement -(Rn) 7 Dowolne

Autoincrement (Rn)+ 8

Autoincrement deferred @(Rn)+ 9 0-15

Byte displacement B^disp(Rn) 10

Byte displacement deferred @B^disp(Rn) 11

Word displacement W^disp(Rn) 12

Word displacement deferred @W^disp(Rn) 13

Longword displacement L^disp(Rn) 14

Longword displacement deferred @L^disp(Rn) 15

Immediate I^#const 8

Absolute @#addr 9

Byte relative Bâddr 10

Byte relative deferred @Bâddr 11 15

Word relative Wâddr 12

Word relative deferred @Wâddr 13

Longword relative Lâddr 14

Longword relative deferred @Lâddr 15

W programie można opuścić oznaczenie I lub S przy argumencie bezpośrednim - asembler wybiera wówczas krótszy format , jeżeli jest wystarczający do zapisania wartości const. Podobnie, można opuszczać oznaczenia B, W lub L w adresacji względnej (typu displacement i relative); również w tym przypadku program asemblujacy koduje przesunięcie w najkrótszym możliwym polu.

Przykłady

Podane dalej przykłady kodowania rozkazów zawierają zapis asemblerowy rozkazu i postać szesnastkową kolejnych bajtów w pamięci.

MOVL -(R3),R4

D0 “MOVL” kod op.

73 “-(R3)” m=7, r=3

54 “R4” m=5, r=4


MOVB ^5(R4),^7(R3)

90 kod op MOVB

A4 disp(R4); m=A, r=4

05 disp=5


07 disp=7

CLRL (R4)+[R5]

D4 kod op CLRL

45 [R5]; m=4, r=5

84 (R4)+; m=8, r=4

ADDL3 ^8(R6),(R7)+,R8

C1 kod op ADDL3


08 disp=8

87 (R7)+; m=8, r=7

58 R8; m=5, r=8

TSTL @#^X12C4

D5 kod op TSTL

9F @# adres; m=9, r=F

C4 adres

12 bezpośredni

00 32-

00 bitowy

Formaty danych

Liczby całkowite ze znakiem (w kodzie uzupełnieniowym), lub bez znaku (dodatnie):

bajt (Byte) - 8b, zakres (-128, 127) lub (0, 255)

słowo (Word) - 16b, zakres (-32768, 32767) lub (0, 65535)

słowo długie, podwójne (Longword) - 32b, zakres (-231

, 231

-1) lub (0, 232

-1)

słowo poczwórne, tetrasłowo (Qadword) - 64b, zakres (-263

, 263

-1) lub (0, 264

-1)

słowo ośmiokrotne, oktasłowo (Octaword) - 128b, zakres (-2127

, 2127

-1) lub (0, 2128

-1)

Jest 5 formatów liczb zmiennopozycyjnych: F, D, G, H i format krótki.

format F - 32b, zakres (2,9x10-37

, 1,7x1038

), dokładność 7 cyfr dzies.

format D - 64b, zakres (2,9x10-37

, 1,7x1038


format G - 64b, zakres (0,56x10-308

, 0,9x10308


format H - 128b, zakres (0,84x10-4932

, 0,59x104932

), dokładność 33 cyfry dzies.

Liczby te są zapisywane na 4, 8 lub 16 bajtach a w formacie krótkim na 6 bitach.

1 t u

s e f

Rys. 3.4. VAX. Format liczby zmiennopozycyjnej.


Wartość liczby zmiennopozycyjnej L wynosi

L = (-1)s x 2

e-b x 0,1f

gdzie s jest bitem znakowym liczby, e jest t-bitowym polem wykładnika, f określa u-bitową część znormalizowanego ułamka dwójkowego a b oznacza przesunięcie kodu wykładnika.

Tab. 3.2. VAX. Wartości parametrów formatów zmiennoprzecinkowych

Format Długość słowa

t u b

F 32 8 23 128

D 64 8 55 128

G 64 11 52 1024

H 128 15 112 16384

Przedstawienie zera wymaga s=0 i e=0. Przypadek s=1, e=0 pozostawiono jako rezerwę.

Oprócz czterech wymienionych, istnieje format zmiennopozycyjny krótki (w przypadku argumentów bezpośrednich typu literal). W formacie tym można przedstawiać tylko liczby dodatnie z zakresu od 0,5 do 120. Argument zajmuje 6 bitów - 3 bity określają wykładnik (e) i 3 bity część ułamkową (f). Wartość liczby wynosi

L = 2e x 0,1f

Liczby dziesiętne (spakowane) P - do16 bajtów (31 cyfr dzies.)

Łańcuch znaków C - od 0 do 65535 bajtów

Pole bitowe V - od 1 do 32 bitów.

Łańcuch numeryczny S 31-bajtowy.

Lista elementów - co najmniej 2 słowa długie.

Powyżej czcionką pogrubioną zaznaczono oznaczenia formatu stosowane w mnemonikach asemblera. Np. rozkaz o ogólnej postaci MOV_ src, dst powoduje przesłanie (MOVe) argumentu src na miejsce dst; w wersji MOVB przesyłane są bajty (B), natomiast w rozkazie MOVL argumentami są podwójne słowa (L). Podobnie, mnemonik DIVP oznacza rozkaz dzielenia (DIVide) liczb dziesiętnych spakowanych (P), a mnemonik CVTPS - zamianę (ConVerT) liczby dziesiętnej spakowanej (P) na łańcuch numeryczny (S).

Lista rozkazów

Lista rozkazów VAX zawiera ponad 300 pozycji, przy czym rozkazy wieloargumentowe są ortogonalne, tzn. poszczególne argumenty mogą być w nich kodowane wzajemnie niezależnie, w dopuszczalny dla każdego z nich sposób. Lista jest symetryczna względem typów danych co znaczy, że jeżeli jakiś rozkaz ma sens dla pewnego typu danych, to rozkaz taki z reguły istnieje. Symetria listy rozkazów i konsekwencja w budowie oznaczeń mnemonicznych pozwala na skrócony zapis określający rodzaj rozkazu (generic operations), stosowany w dalszym opisie. Np. zapis MCOM_ {B,W,L} oznacza 3 rozkazy przesłania, mające mnemoniki MCOMB, MCOMW, MCOML; symbole typu danych umieszczone w nawiasach { } należy podstawić w miejsce podkreślonej spacji (_).

W rubryce "oznaczenie" nie podano specyfikatorów argumentów (parametrów rozkazu) - ich liczba i postać wynika z typu argumentu (np. dla danych stp. i zmp. wystarcza adres, dla liczb dziesiętnych trzeba adresu i długości liczby itp.).

W rubryce "liczba rozkazów" podano liczbę różnych kodów, która jest czasami mniejsza od liczby mnemoników (np. rozkaz CLRL ma taki sam kod jak CLRF).

Podziału na grupy dokonano ze względu na rodzaj operacji, choć działania na takich formatach jak łańcuchy bajtów, pola zmiennej długości czy kolejki zgrupowano w osobnych tablicach.


Zmiany typu danych

Rozkazy zmiany typu danych (tab. 3.2) umożliwiają wykonywanie obliczeń w dowolnej postaci, o ile tylko dokładność przekształcenia jest do przyjęcia (tab.3.3). W rozkazach konwersji liczb dwójkowych określa się argument źródłowy (src) i docelowy (dst):

CVT src,dst

W rozkazach z argumentem w postaci dziesiętnej spakowanej musi być określony adres (addr) i długość (len), np.:

CVTPL srclen, srcaddr,dst

a dla argumentów w postaci łańcucha numerycznego T podawany jest jeszcze adres tablicy kodowej (tbladdr) ostatniego bajta (zawierającego znak liczby i ostatnią cyfrę), np.:

CVTPT srclen,srcaddr,tbladdr,dstlen,dstaddr

Tab.3.2. VAX. Rozkazy zmiany typu danych.

Oznaczenie

Opis

Liczba

rozkazów

CVT_ _

{B,W,L,F,D,G,H} {B,W,L,F,D,G,H}

Zmiana typu i formatu liczb stp. i zmp. (bez kombinacji DG, GD oraz tożsamościowych: BB,...,HH)

40

CVT_P {L,S,T} Zmiana liczby stp.L lub łańcucha numer. na liczbę dzies. spak.

3

CVTP_ {L,S,T} Zmiana liczby dzies. spakowanej na stp.L lub łańcuch numeryczny

3

CVTR_L {D,F,G,H} Zmiana liczby zmp. na stp.L z zaokrągleniem

4

Tab.3.3. VAX. Sposób zmiany liczb zmp. rozkazami CVT_ _

Zmiana dokładna

Zaokrąglenie

Obcięcie

CVT_F {B,W}

CVT_D {B,W,L,F}

CVT_G {B,W,L,F}

CVT_H {B,W,L,F,D,G}

CVT_F {L,D,G,H}

CVTHD

CVTHG

CVTR_L {F,D,G,H}

CVT_ _ {F,D,G,H} {B,W,L}

Przesłania

Rozkazy przesłań pozwalają przesyłać dane dowolnego typu między rejestrami i pamięcią:

MOV src,dst

Przesyłane dane mogą być uzupełniane logicznie (MCOM) lub traktowane jako liczba ze znakiem i negowane (MNEG ).

Przesłanie adresu (MOVA ) ma zawsze jako argument docelowy słowo długie L.

Do komunikacji ze stosem systemowym jest jeden rozkaz PUSHL, chociaż komunikację tę można zrealizować dla dowolnego typu danych rozkazami MOV. Np. nieistniejący rozkaz przesłania na stos słowa poczwórnego (Q) o adresie A - “PUSHQ A” jest równoważny rozkazowi

MOVQ A,-(SP)

a rozkaz “POPQ A” - rozkazowi


MOVQ (SP)+, A

Rozkazy PUSHR mask i POPR mask odpowiednio składają na stos i zdejmują (w odwrotnej kolejności) ze stosu rejestry uniwersalne R0..R15 wskazane w 16-bitowym słowie mask. W asemblerze maskę można podać w czytelnej postaci jako argument bezpośredni, np.:

PUSHR #M<R3,R4,R7,R9>

Następujące grupy rozkazów mają jednakowe kody:

MOVA {L,F}, MOVA {H,O}, MOVA {Q,D,G},

i

PUSHA {L,F}, PUSHA {H,O}, PUSHA {Q,D,G},

Tab.3.4. VAX. Rozkazy przesłań.

Oznaczenie

Opis

Liczba rozkazów

MOV_ {B,W,L,O,Q,D,F,G,H,P}

MCOM _ {B,W,L}

MNEG _ {B,W,L,D,F,G,H}

MOVZB_ {W,L}

MOVZWL

MOVA_ {B,W,L,O,Q,D,F,G,H}

PUSHL

PUSHR

POPR

PUSHA_ {B,W,L,O,Q,D,F,G,H}

Przesłanie danych stp., zmp. i dziesiętnych spakowanych.

Przesłanie uzupełnienia logicznego.

Przesłanie negacji liczby (zmiana znaku).

Przesłanie logiczne bajta

(z wypełnieniem zerami)

Przesłanie logiczne słowa

(z wypełnieniem zerami)

Przesłanie adresu.

Przesłanie słowa L na stos.

Przesłanie rejestrów L na stos.

Pobranie rejestrów ze stosu.

Przesłanie adresu na stos.

10

3

7

2

1

5

1

1

1

5

Działania arytmetyczne

VAX realizuje 4 podstawowe działania arytmetyczne na liczbach stp., zmp. i na liczbach dziesiętnych w postaci spakowanej. Rozkazy te występują w dwóch wersjach:

- jako 2-argumentowe (ADD_2, SUB_2, MUL_2, DIV_2):

dst src op dst,

- lub jako 3-argumentowe (ADD_3, SUB_3, MUL_3, DIV_3):

dst src1 op src2.

Oznaczenia rozkazów dziesiętnych podają liczbę parametrów (adres i długość każdego argumentu) - stąd: ADDP4, ADDP6, SUBP4, SUBP6.

Działania ze zwiększoną dokładnością są możliwe dzięki rozkazom ADWC i SBWC oraz EMUL, EMOD_ i EDIV.

Rozkazy ADWC i SBWC wykonują odpowiednio dodawanie i odejmowanie argumentów w formacie L z uwzględnieniem znacznika C (przeniesienie wygenerowane w poprzedniej operacji). Np. rozkaz

ADWC add,sum

wykonuje działanie

sum sum + add + C


Rozkaz

EMUL mulr,muld,add,prod

daje iloczyn (prod) w formacie Q, podczas gdy mnożna (muld) i mnożnik (mulr) są w formacie L. Do wyniku dodawany jest składnik add.

Rozkaz

EDIV divr,divd,quo,rem

dzieli dzielną (divd) w formacie Q przez dzielnik (divr) w formacie L dając iloraz (quo) i resztę (rem) w formacie L; normalne dzielenie DIV nie zapamiętuje reszty.

Rozkaz

POLY_ arg,degree,tbladdr

oblicza wartość wielomianu stopnia d (parametr degree) metodą Hornera dla argumentu x (parametr arg); współczynniki wielomianu Ci muszą być umieszczone pod adresem tabaddr poczynając od

najwyższego stopnia. Wynik jest umieszczany w rejestrach R0..R5

wynik = C0 + x*(C1 + x*(C2 + ... + x*Cd)).

Format argumentu, współczynników i wyniku jest określony przez typ rozkazu (D,F,G lub H).

Tab.3.5. VAX. Rozkazy arytmetyczne.

Oznaczenie

Opis

Liczba

rozkazów

ADD_2 {B,W,L,D,F,G,H}

ADD_3 {B,W,L,D,F,G,H}

ADDP4

ADDP6

ADWC

SUB_2 {B,W,L,D,F,G,H}

SUB_3 {B,W,L,D,F,G,H}

SUBP4

SUBP6

SBWC

MUL_2 {B,W,L,D,F,G,H}

MUL_3 {B,W,L,D,F,G,H}

MULP

DIV_2 {B,W,L,D,F,G,H}

DIV_3 {B,W,L,D,F,G,H}

DIVP

EMUL

EDIV

EMOD_ {D,F,G,H}

DEC_ {B,W,L}

INC_ {B,W,L}

CRC

POLY_ {D,F,G,H}

INDEX

Dodawanie 2 argumentowe

Dodawanie 3 argumentowe

Dodawanie dziesiętne 2 arg.

Dodawanie dziesiętne 3 arg.

Dodawanie przeniesienia

Odejmowanie 2 argumentowe

Odejmowanie 3 argumentowe

Odejmowanie dziesiętne 2 arg.

Odejmowanie dziesiętne 3 arg.

Odejmowanie przeniesienia

Mnożenie 2 argumentowe

Mnożenie 3 argumentowe

Mnożenie liczb dziesiętnych

Dzielenie 2 argumentowe

Dzielenie 3 argumentowe

Dzielenie liczb dziesiętnych

Mnożenie z rozszerzonym ilorazem

Dzielenie z resztą

Mnożenie z rozszerz. mnożnikiem

Zmniejszenie o 1

Zwiększenie o 1

Obliczenie kodu resztowego

Obliczenie wielomianu

Obliczenie indeksu w tablicy danych

stałej długości

7

7

1

1

1

7

7

1

1

1

7

7

1

7

7

1

1

1

4

3

3

1

4

1


Rozkaz CRC służy do obliczania pola kontrolnego (CRC) stosowanego przy transmisji łańcuchów bitowych do wykrywania błędów transmisji. Obliczenie CRC polega na dzieleniu strumienia bitów przez zadany wielomian. Rozkaz CRC umożliwia podawanie wielomianów 32-bitowych i generuje wynik również 32-bitowy. W systemach transmisji pole CRC jest zwykle generowane (przy nadawaniu) i sprawdzane (przy odbiorze) w sposób sprzętowy przez układy nadajników-odbiorników liniowych.

Działania logiczne

Rozkazy logiczne wykonują działania na argumentach w formacie B, W i L traktowanych jako łańcuchy binarne. Możliwe są działania iloczynu logicznego (BIC_), sumy logicznej (BIS_) i różnicy symetrycznej (XOR_) - zarówno w postaci 2-argumentowej jak i 3-argumentowej (tab.3.6 i 3.7)

Tab.3.6. VAX. Podstawowe działania logiczne

Rozkaz

Działanie

BIC_2 mask,dst

BIC_3 mask,src,dst

BIS_2 mask,dst

BIS_3 mask,src,dst

XOR_2 mask,dst

XOR_3 mask,src,dst

dst dst and (not mask)

dst src and (not mask)

dst dst or mask

dst src or mask

dst dst xor mask

dst src xor mask

Tab.3.7. VAX. Rozkazy logiczne

Oznaczenie

Opis

Liczba rozkazów

CLR_ {B,W,L,O,Q,D,F,G,H}

BIC_2 {B,W,L}

BIC_3 {B,W,L}

BIS_2 {B,W,L}

BIS_3 {B,W,L}

XOR_2 {B,W,L}

XOR_3 {B,W,L}

Zerowanie

Zerowanie bitów wg maski (2 arg.)

Zerowanie bitów wg maski (3 arg.)

Ustawianie bitów wg maski (2 arg.)

Ustawianie bitów wg maski (3 arg.)

Obliczanie różnicy symetrycznej (2 arg.)

Obliczanie różnicy symetrycznej (3 arg.)

5

3

3

3

3

3

3

Niektóre rozkazy CLR_ maja jednakowe kody, sa to: CLRH i CLRO, CLRL i CLRF oraz CLRQ, CLRD i CLRG.

Przesunięcia

Rozkazy przesunięć (tab.3.8) w przeciwieństwie do rozwiązań stosowanych w innych maszynach, powodują również przesłanie przesuniętego argumentu src we wskazane miejsce dst; np.:

ASH_ count,src,dst


Liczba pozycji i kierunek przesunięcia zależy od parametru count: przy wartościach dodatnich następuje przesunięcie w lewo, przy ujemnych - w prawo:

count < 0 => dst count shra dst;

count > 0 => dst count shl dst.

Analogicznie działa rozkaz ROTL.

Przy przesuwaniu liczb dziesiętnych podawana jest długość źródła i przeznaczenia a także 1-bajtowy kod sposobu zaokrąglenia (round):

ASHP count,srclen,srcaddr,round,dstlen,dstaddr.

Tab.3.8. VAX. Rozkazy przesunięć

Oznaczenie

Opis

Liczba rozkazów

ASH_ {L,Q}

ROTL

ASHP

Przesunięcie arytmetyczne w lewo lub w prawo o n bitów

Przesunięcie cykliczne w lewo lub w prawo o n bitów

Przesunięcie liczby dzies. w lewo lub w prawo o n tetrad

2

1

1

Badanie warunków

Rozkazy testowania (tab.3.9) umożliwiają wykonywanie rozkazów warunkowych celem rozgałęzienia programu. Rozkazy TEST_ i BIT_ sprawdzają zerowość wyniku (znacznik Z) i bit znakowy wyniku (znacznik N). Rozkaz TEST_ jest jednoparametrowy natomiast BIT_ - dwuparametrowy jednak w żadnym przypadku wynik nie jest zapamiętywany, podobnie jak w rozkazie porównania arytmetycznego CMP_.

W grupie tej mieszczą się też rozkazy pomocne przy organizowaniu pętli programowych takie jak

ACB_ limit,add,index,displ

Rozkaz ten przy każdym wystąpieniu aktualizuje zmienną index dodając stały przyrost add, po czym nowa wartość indeksu jest porównywana z wartością graniczną limit i następuje skok na odległość displ:

(add geq 0) and (index +add leq limit) => PC PC + displ;

(add lss 0) and (index +add geq limit) => PC PC + displ.


Tab.3.9. VAX. Rozkazy badania warunków.

Oznaczenie

Opis

Liczba rozkazów

TST_ {B,W,L,D,F,G,H}

BIT_ {B,W,L}

CMP_ {B,W,L,D,F,G,H}

CMPP3

CMPP4

ACB_ {B,W,L,D,F,G,H}

AOBLEQ

AOBLSS

SOBGEQ

SOBGTR

Testowanie warunków N i Z

Testowanie bitów wg maski

Porownanie liczb stp. lub zmp.

Porównanie liczb dzies. jednakowej

długości

Porównanie liczb dzies. różnej długości

Dodanie przyrostu i skok gdy wynik

przekracza granicę

Dodanie jedynki i skok gdy wynik

mniejszy lub równy granicy

Dodanie jedynki i skok gdy wynik

mniejszy od granicy

Odjęcie jedynki i skok gdy wynik większy

lub równy granicy

Odjęcie jedynki i skok gdy wynik większy

od granicy

7

3

7

1

1

7

1

1

1

1

Działania na łańcuchach bajtów

Rozkazy działające na łańcuchach (tab.3.10) dają możliwości różnorodnego badania i przekształcania łańcuchów znakowych o zadanej długości (0-65535 bajtów).

Rozkaz

MOVC3 len,srcaddr,dstaddr

przepisuje łańcuch z miejsca (srcaddr) pod wskazany adres (dstaddr) bez zmiany jego długości (len).

Podobny rozkaz

MOVC5 srclen,srcaddr,fill,dstlen,dstaddr

przepisuje łańcuch źródłowy w miejsce przeznaczenia o określonej długości, uzupełniając ewentualne wolne miejsca 1-bajtowym wypełniaczem fill; np. rozkaz

MOVC5 #0,0,#A/*/,#60,TOTU

umieści w pamięci, poczynając od adresu TOTU, 60 gwiazdek (kody ASCII tego znaku) gdyż długość łańcucha źródłowego jest zerowa.

Rozkaz

LOCC char,len,addr

przegląda łańcuch od adresu addr porównując kolejne znaki z zadanym wzorcem char; po wykryciu zgodności jest zerowany znacznik Z, do rejestru R0 jest wpisywana liczba bajtów pozostałych w łańcuchu a do rejestru R1 - adres zlokalizowanego bajta.

Rozkaz

MOVTC srclen,srcaddr,fill,tbladdr,dstlen,dstaddr

tłumaczy znaki łańcucha źródłowego src według kodu zadanego tablicą tbl i wpisuje je do łańcucha przeznaczenia dst uzupełniając ewentualne wolne bajty wypełniaczem fill (jeżeli srclen < dstlen).


W rejestrach R0-R5 jest zapisywany stan, przy jakim została zakończona operacja przekształcania łańcucha źródłowego. Wartości kolejnych bajtów źródłowych są traktowane jako indeksy tablicy i element tablicy odpowiadający indeksowi jest wpisywany jako bajt przeznaczenia. Jeżeli tablica kodowa ma 256 pozycji, wówczas każda kombinacja 8-bitowa znajdzie swój odpowiednik.

Tab.3.10. VAX. Rozkazy działające na łańcuchach bajtów

Oznaczenie

Opis

Liczba rozkazów

MOVC3

MOVC5

CMPC3

CMPC5

LOCC

SKPC

SPANC

SCANC

MATCHC

MOVTC

MOVTVUC

EDITPC

Przepisanie łańcucha

Przepisanie łańcucha ze zmianą

długości i wypełnieniem

Porównanie łańcuchów jednakowej

długości

Porównanie łańcuchów różnej długości

Lokalizacja zadanego wzorca w łańcuchu

Lokalizacja bajta różnego od zadanego

wzorca

Lokalizacja bajta, dla którego

maska & element tablicy = 0

Lokalizacja bajta, dla którego

maska & element tablicy 0

Lokalizacja zadanego ciągu bajtów

w łańcuchu

Przekształcenie łańcucha wg zadanej

tablicy

Przekształcenie łańcucha wg zadanej

tablicy aż do do wykrycia zadanego

znaku

Przekształcenie liczby dzies. P

w łańcuch ASCII wg zadanego wzorca

1

1

1

1

1

1

1

1

1

1

1

1

Działania na polach zmiennej długości

Jedną z osobliwości VAX jest możliwość operowania na polach bitowych zmiennej długości (tab.3.11). Rozkazy FFS i FFC przeszukują podane pole od pozycji startpos w lewo aż do napotkania określonego bitu (odpowiednio 1 lub 0); położenie zlokalizowanego bitu w stosunku do bazy (base) jest wpisywane na miejsce określone przez parametr findpos. Rozmiar pola (size) nie może być większy niż 32 bity. Składnia obu rozkazów jest następująca:

kod_op startpos,size,base,findpos

Rozkaz

INSV src,pos,size,base

wstawia początkowy fragment podwójnego słowa (src) w miejsce określone przez parametry base i pos:

M[base]<(size+pos-1):pos> src<(size-1):0>


Rozkazy EXTV i EXTZV mające składnię:

kod_op pos,size,base,dst

przepisują określone pole na miejse wskazanego słowa L (dst); np. rozkaz

EXTZV #5,#12,R7,R2

przepisze 12 bitów <16:5> rejestru R7 na pozycje <11:0> rejestru R2 wypełniając pozostałe pozycje <31:12> tego rejestru zerami.

Tab.3.11. VAX. Rozkazy działające na polach zmiennej długości

Oznaczenie

Opis

Liczba rozkazów

FFS

FFC

INSV

EXTV

EXTZV

CMPV

CMPZV

Poszukiwanie pierwszego bitu = 1

Poszukiwanie pierwszego bitu = 0

Wstawienie pola bitów

Przeniesienie pola bitów z powieleniem

bitu znakowego

Przeniesienie pola bitów z dopełnieniem

zerami

Porównanie arg. źródłowgo z polem bitów

rozszerzonym o powielony bit znakowy

Porównanie arg. zródłowgo z polem bitów

dopełnionym zerami

1

1

1

1

1

1

1

Działania na kolejkach

Działania na strukturach listowych (kolejkach) są różne dla kolejek bezwzględnych i względnych (tab.3.12). W każdym przypadku dotyczą one wstawienia bądź usunięcia jednego elementu listy. W kolejkach względnych dostępny jest jedynie początek i koniec kolejki. Operacje na tych kolejkach są wykonywane z jednoczesnym zablokowaniem dostępu (interlocked) innym procesorom, jeżeli takie działają w systemie wieloprocesorowym.

W rozkazach INSQUE i REMQUE parametrami są: adres odpowiednio źródła bądź przeznaczenia (entry) i adres miejsca w kolejce (elementu poprzedzającego wpisywany bądź usuwany) (addr). W pozostałych rozkazach podaje się adres źródła bądź przeznaczenia i adres początku kolejki (header).

Tab.3.12. VAX. Rozkazy działające na kolejkach

Oznaczenie

Opis

Liczba rozkazów

INSQUE

REMQUE

INSQHI

INSQTI

REMQHI

REMQTI

Wstawienie elementu do kolejki

Usunięcie elementu z kolejki

Wstawienie na początek kolejki (*)

Wstawienie na koniec kolejki (*)

Usunięcie z początku kolejki (*)

Usunięcie z końca kolejki (*)

1

1

1

1

1

1

(*) - rozkazy z blokadą dostępu do argumentów.


Blokada dostępu do argumentów

Oprócz rozkazów operujących na kolejkach względnych, blokadę dostępu do swoich argumentów stosują jeszcze 3 rozkazy VAX (tab.V.12). Rozkaz ADAWI działa tak jak rozkaz ADDW2 a rozkazy BBSSI i BBCCI tak jak, odpowiednio, rozkazy BBSS i BBCC. Rozkazy skoków z blokadą mogą być zastosowane do realizacji semaforów w procesach współbieżnych.

Tab.3.13. VAX. Rozkazy z blokadą dostępu do argumentów

Oznaczenie

Opis

Liczba rozkazów

ADAWI

BBSSI

BBCCI

Dodawanie 2-argumentowe liczb stp.W z wyrównaniem do adresu parzystego

Skok gdy bit = 1 z ustawieniem tego bitu

Skok gdy bit = 0 z wyzerowaniem tego bitu

1

1

1

Rozkazy skokowe

W grupie rozkazów skokowych (tab.3.14) jest jeden rozkaz skoku bezwarunkowego JMP dst w pełnym zakresie adresów i duża liczba skoków warunkowych względnych. Skoki względne wymagają tylko jednego bajta do określenia adresu przeznaczenia, podczas gdy skok bezwzględny może zajmować na adres aż 5 bajtów (1-bajtowy tryb adresacji + 32-bitowy adres). Skoki warunkowe mogą się wykonywać ze względu na (tab.3.15):

- stan znaczników N, Z, V i C w słowie stanu PSW (branch),

- wartość wskazanego bitu w polu typu V (branch on bit and modify),

- wartość bitu zerowego wskazanego słowa (branch on low bit).

Pierwsza z wymienionych grup ma mnemoniki skojarzone z typem danych, które były porównywane dla ustalenia warunku skoku; stąd są skoki "znakowe" (signed) i "bezznakowe" (unsigned) - te ostatnie mają na końcu mnemonika literę U. Rozkazy tej grupy są jednoparametrowe:

kod_op disp

i w przypadku spełnienia warunku określonego w kodzie operacyjnym modyfikują licznik rozkazów:

PC PC + disp.

Rozkazy drugiej grupy mają składnię:

kod_op pos,base,disp

i modyfikują PC wtedy gdy jednobitowe pole typu V (M[base]<pos>) ma wartość 0 (rozkazy BBC_) lub 1 (rozkazy BBS_). W rozkazach z modyfikacją, bez względu na to czy skok był efektywny czy nie, następuje ustawienie testowanego bitu (rozkazy BBCS i BBSS) lub jego wyzerowanie (rozkazy BBCC i BBSC).

Rozkazy trzeciej grupy:

kod_op src,disp

zmieniają przebieg programu na podstawie badania zerowego bitu we wskazanym słowie podwójnym M[src]<0>.

Skok wyliczany (case, switch) ma składnię

CASE_ selector,base,limit,displ[0],...,displ[limit]

i powoduje obliczenie różnicy między bazą i selektorem a następnie przejście do miejsca określonego przez tę różnicę - jeżeli jest nie większa od granicy (limit):

tmp selector - base; next

(tmp leq limit) => PC PC + displ[tmp].

Typ rozkazu (B, W lub L) określa format selektora, bazy i granicy, długość skoku (displ) zawsze jest kodowana na 16 bitach (W).


W maszynach VAX odróżniane są podprogramy i procedury. Wywoływanie podprogramów odbywa się rozkazami JSB i BSB_ a powrót z nich rozkazem RSB, natomiast wywołanie procedury następuje rozkazem CALLG lub CALLS a powrót do programu głównego rozkazem RET.

Wywołanie podprogramu zapamiętuje na stosie licznik rozkazów i powoduje przejście pod adres wskazany w rozkazie - bezwzględny (dst) w JSB lub względny (displ) w BSB_. Rozkaz RSB odtwarza licznik rozkazów ze stosu:

PC M[SP]; next SP SP + 4.

Rozkaz wywołujący procedurę wskazuje adres wejścia do procedury (dst), pod którym musi być umieszczona 16-bitowa maska wejściowa poprzedzająca rozkazy programu. Maska na pozycjach <11:0> wskazuje te spośród dwunastu rejestrów R0..R11, które mają być zapamiętane na stosie (oprócz tego zawsze są zapamiętywane rejestry R12..R15 czyli AP, FP, SP i PC). Rejestry wskazane w masce są automatycznie odtwarzane przy wyjściu z procedury rozkazem RET.

Rozkaz CALLG wywołuje procedurę z listą argumentów umieszczoną w dowolnym miejscu pamięci (arglist)

CALLG arglist,dst

natomiast rozkaz CALLS wywołuje procedurę z listą argumentów umieszczoną na stosie (lista ta, zawierająca numarg pozycji, po rozkazie RET jest automatycznie usuwana ze stosu)

CALLS numarg,dst.

Na początku wykonywania rozkazu CALL_ na stosie wyrównanym do podwójnego słowa jest umieszczana tzw. ramka (stack frame, call frame) zawierająca wskazane do przechowania rejestry, PC, FP, AP, fragment słowa stanu PSW<14:5>, maskę wejściową i pewne informacje sterujące obsługę sytuacji wyjątkowych. Adres ramki (bieżąca wartość SP) jest wpisywany do FP, co umożliwia wyjście z procedury (rozkazem RET) bez konieczności wcześniejszego porządkowania stosu. W czasie wykonywania procedury, rejestr AP zawsze pamięta adres listy argumentów - w rozkazie CALLG wzięty z parametru arglist, w rozkazie CALLS wzięty z rejestru SP przed umieszczeniem na stosie parametru numarg i ramki.


Tab.3.14. VAX. Rozkazy sterujące przebieg programu

Oznaczenie

Opis

Liczba rozkazów

JMP

BRB

BRW

B...

(zob. tab.3.15)

BB..

(zob. tab.3.15)

BLB.

(zob. tab.3.15)

CASE_ {B,W,L}

JSB

BSBB

BSBW

RSB

CALLG

CALLS

RET

Skok bezwzględny

Skok względny w zakresie

-128..+127 bajtów

Skok względny w zakresie

-32768..+32767 bajtów

Skoki względne (w zakresie

-128..+127 bajtów) według stanu

znaczników N,Z,V i C


-128..+127 bajtów) według wartości

wskazanego bitu pola V


-128..+127 bajtów) według wartości

bitu <0> wskazanego słowa L

Skok wyliczany

Skok do podprogramu (bezwzgledny)

Skok do podprogramu (względny,

w zakresie -128..+127 bajtów)

Skok do podprogramu (względny,

w zakresie -32768..+32767 bajtów)

Powrót z podprogramu

Wywołanie procedury z przekazaniem

argumentów przez listę argumentów

Wywołanie procedury z przekazaniem

argumentów przez stos

Powrót z procedury

1

1

1

12

6

2

3

1

1

1

1

1

1

1


Tab.3.15. VAX. Warunki efektywności skoków warunkowych

Rozkaz

Warunek

Nazwa

BCC

BCS

BVC

BVS

BEQL

BNEQ

BLSS

BLEQ

BGTR

BGEQ

BEQLU

BNWQU

BLSSU

BLEQU

BGTRU

BGEQU

C = 0

C = 1

V = 0

V = 1

Skoki "znakowe"

Z =1

Z = 0

N = 1

(N or Z) = 1

(N or Z) = 0

N = 0

Skoki "bezznakowe"

Z =1

Z = 0

C = 1

(C or Z) = 1

(C or Z) = 0

C = 0

Branch on carry clear

Branch on carry set

Branch on overflow clear

Branch on overflow set

Branch on equal

Branch on not equal

Branch on less

Branch on less or equal

Branch on greater

Branch on greater or equal

Branch on equal unsigned

Branch on not equal unsigned

Branch on less unsigned

Branch on less or equal unsigned

Branch on greater unsigned

Branch on greater or equal unsigned

BBC

BBCC

BBCS

BBS

BBSC

BBSS

bit_pola_V = 0

bit_pola_V = 0

bit_pola_V = 0

bit_pola_V = 1

bit_pola_V = 1

bit_pola_V = 1

Branch on bit clear

Branch on bit clear and clear

Branch on bit clear and set

Branch on bit set

Branch on bit set and clear

Branch on bit set and set

BLBC

BLBS

bit<0>_słowa_L = 0

bit<0>_słowa_L = 1

Branch on low bit clear

Branch on low bit set

Rozkazy systemowe

Niektóre rozkazy systemowe (tab.3.16) mogą być stosowane tylko przez system operacyjny na najbardziej chronionym poziomie dostępu (Kernel). Są to rozkazy dotyczące tzw. rejestrów wewnętrznych procesora (IPR), rozkazy przełączające procesy i rozkaz HALT.

Każdy rejestr wewnętrzny mający implementację sprzętową można zapamiętać w miejscu dst rozkazem

MFPR procreg,dst,


gdzie procreg jest numerem tego rejestru (z przedziału 0..63). Analogicznie, ładowanie rejestru wewnętrznego z miejsca src odbywa się rozkazem

MTPR src,procreg.

Przełączanie procesów następuje po upływie czasu przeznaczonego dla danego procesu lub wtedy, gdy proces czeka na jakieś zdarzenie. System operacyjny zmienia wtedy kontekst procesu stosując rozkazy SVPCTX i LDPCTX. "Kontekst procesu" jest określony przez strukturę danych nazwaną blokiem sterującym proces (PCB - Process control block) złożoną z zawartości czterech wskaźników stosu (dla trybu Kernel, Executive, Supervisor i User), wszystkich rejestrów uniwersalnych, podwójnego słowa stanu stanu PSL i 4 rejestrów definiujących fizyczne położenie obydwu wirtualnych obszarów pamięci danego procesu (program region i control region). Adres aktualnego bloku PCB jest umieszczony w rejestrze wewnętrznym PCBB (processor control block base register).

Bezparametrowe rozkazy SVPCTX i LDPCTX przesyłają dane między odpowiednimi rejestrami a blokiem PCB.

Cztery rozkazy

CHM_ code

zmieniają tryb ochrony procesu na wskazany w kodzie operacyjnym, parametr code służy do identyfikacji usługi żądanej w nowo osiągniętym trybie. Rozkazy te zmieniają wskaźnik stosu na właściwy dla danego trybu i na tym nowym stosie zapamiętują PSL, PC i parametr code.

Rozkaz REI służy do powrotu z programu obsługi przerwania lub sytuacji wyjątkowej i w tym celu odtwarza z aktualnego stosu zawartość PC i PSL. Rozkazy BICPSW i BISPSW mające składnię

kod_op mask

służą do zerowania i ustawiania bitów sterujących w 16-bitowym słowie stanu PSW (bity <15:8> maski musza być zerowe).

Rozkaz XFC (extended function call) odpowiada kodowi operacyjnemu FEh zarezerwowanemu dla ewentualnych operacji zdefiniowanych przez użytkownika. Operacje takie mogą być implementowane na poziomie mikroprogramowym np. w zapisywalnej pamięci sterującej.


Tab.3.16. VAX. Rozkazy systemowe

Oznaczenie

Opis

Liczba rozkazów

CHMK

CHME

CHMS

CHMU

REI

PROBER

PROBEW

SVPCTX

LDPCTX

MTPR

MFPR

MOVPSL

BICPSW

BISPSW

BPT

BUG_ {W,L}

XFC

NOP

HALT

Zmiana trybu na Kernel

Zmiana trybu na Executive

Zmiana trybu na Supervisor

Zmiana trybu na User

Powrót z przerwania

Sprawdzenie dostępności odczytu

Sprawdzenie dostępności zapisu

Zapamiętanie kontekstu procesu(*)

Odtworzenie kontekstu procesu (*)

Zapamiętanie wskazanego rejestru

wewnętrznego procesora (*)

Odczytanie wskazanego rejestru

wewnętrznego procesora (*)

Przesłanie podwójnego słowa stanu

Zerowanie bitów PSW wg maski

Ustawienie bitów PSW wg maski

Przerwanie programowe "punkt wstrzymania"

Żądanie raportu o wykrytych błędach

(przerwanie programowe)

Wywołanie operacji zdefiniowanej przez

użytkownika ( przerw. progr.)

Brak działania

Zatrzymanie pracy procesora(*)

1

1

1

1

1

1

1

1

1

1

1

1

1

1

1

2

1

1

1

(*) Rozkaz uprzywilejowany - dostępny tylko w trybie Kernel.


Nieporządek miły.

Adam Mickiewicz

8051 - mikrokomputer jednoukładowy Historia

Procesor 8051 został opracowany przez firmę Intel w 1980 r. i był ulepszoną wersją mikrosterownika 8048 z 1976 roku, reklamowanego wówczas jako pierwszy mikrokomputer jednoukładowy (single-chip). Układ ten rzeczywiście zawierał wszystkie elementy komputera wg klasycznego modelu von Neumanna: oprócz procesora centralnego (CPU) była jeszcze pamięć programów typu ROM (lub EPROM w modelu 8748), pamięć danych (RAM) i porty wejścia-wyjścia do komunikacji z urządzeniami zewnętrznymi.

Obecnie architektura 8051 jest realizowana przez kilkunastu producentów w wielu odmianach różniących się obudową, zasilaniem, częstotliwością zegara, obsługą przerwań, realizacją pamięci, modułami ułatwiającymi sprzęg z resztą systemu itp.

Typowy mikroprocesor 8051 zawiera:

8-bitowy procesor centralny,

2 - 4 liczniki/zegary 16-bitowe,

wektorowy system przerwań (5 lub 6 zgłoszeń przyjmowanych na 2 poziomach priorytetu),

32 indywidualnie programowane linie wejścia-wyjścia zebrane w 4 porty 8-bitowe,

programowany port transmisji szeregowej (UART) współpracujący z jednym z zegarów,

4 Kbajty wewnętrznej pamięci programu ROM (również w wersjach umożliwiających zmianę jej zawartości przez użytkownika: EPROM lub typu „flash memory”)

128 bajtów wewnętrznej pamięci danych RAM oraz 21 tzw. rejestry specjalne (SFR), niektóre z nich adresowane bitowo.

Rejestry procesora

Są cztery zestawy (banks) po 8 rejestrów uniwersalnych (R0..R7) i 21 rejestrów specjalnych (SFR - special function registers). Licznik rozkazów (PC) jest 16-bitowy i nie wchodzi w skład rejestrów specjalnych. Wszystkie rejestry procesora, za wyjątkiem PC i DPTR są 8-bitowe. Rejestry uniwersalne są stosowane do adresowania pamięci i do przechowywania argumentów operacji; numer aktualnego zestawu jest wskazywany przez odpowiednie pole słowa stanu (PSW). Rejestry specjalne przechowują dane lub informacje sterujące przeznaczone do wyróżnionych bloków funkcjonalnych mikrokomputera:

A (lub ACC) akumulator, główny rejestr arytmometru

B rejestr pomocniczy akumulatora

SP wskaźnik stosu,

DPTR wskaźnik danych w pamięci zewnętrznej, jest to rejestr 16-bitowy złożony z DPH (część bardziej znacząca) i DPL (część mniej znacząca)

PSW słowo stanu procesora,

P0..P3 4 porty równoległe we/wy,

IP rejestr priorytetu przerwań,

IE rejestr maski przerwań,

TMOD rejestr trybu pracy liczników,

TCON rejestr sterujący liczników,

T0, T1 rejestry licznika 0 i 1, są to rejestry 16-bitowe złożone, odpowiednio, z THi i TLi,

SCON rejestr sterujący transmisji szeregowej,

SBUF bufor transmisji szeregowej,

PCON rejestr sterujący


Stos może się mieścić tylko w początkowym obszarze wewnętrznej pamięci danych (do adresu 7Fh). Przyrost stosu następuje w kierunku adresów rosnących (inaczej niż np. w mikroprocesorach rodziny 80x86). Po inicjalizacji wartość SP wynosi 7, co odpowiada umieszczeniu stosu nad pierwszym zestawem rejestrów uniwersalnych.

Słowo stanu PSW (rys. 4.1) zawiera znaczniki ostatnio wykonanej operacji (CY, AC, OV, P) oraz wskaźnik aktualnego zestawu rejestrów (RS0, RS1). Pozycja CY służy też jako akumulator w operacjach bitowych.

7 6 5 4 3 2 1 0

CY AC RS1 RS0 OV P

Przeniesienie Przeniesienie połówkowe

Zestaw rejestrów

Nadmiar Parzystość

00 – 0..7

01 – 8..F 10 – 10..17 11 – 18..1F

Rys. 4.1. Słowo stanu procesora (PSW)

Port P3, oprócz zwykłych funkcji równoległego wejścia-wyjścia, może też przenosić sygnały sterujące, dla których nie przewidziano wyprowadzeń na szynie sterującej mikrokomputera (rys.4.2):

RD, WR sterowanie zewnętrzną pamięcią danych,

T0, T1 wejścia sygnałów zliczanych w licznikach,

INT0, INT1 wejścia przerwań zewnętrznych,

TxD, RxD wyjście nadajnika i wejście odbiornika transmisji szeregowej.

7 6 5 4 3 2 1 0

RD WR T1 T0 INT1 INT0 TxD RxD

Rys. 4.2. Sygnały sterujące portu P3

Porty P0 i P2 spełniają dodatkowe funkcje szyny adresowej i szyny danych przy dostępie do pamięci zewnętrznej.

Pamięć

Procesor 8051 dysponuje dwoma przestrzeniami adresowymi: pamięcią programu i pamięcią danych (rys.4.3). Każda z tych przestrzeni ma 65536 bajtów adresowanych od 0 do FFFFh. Pamięć programu jest adresowana z 16-bitowego licznika rozkazów (PC), przy czym, jeżeli adres przekracza 0FFFh, to jest generowany sygnał PSEN (program store enable) odróżniający zewnętrzną pamięć programu od pamięci danych.

Początkowe 4 kB pamięci programu (0..0FFFh) mogą być adresowane zarówno w pamięci wewnętrznej jak i zewnętrznej. Rozróżnienie tych dwóch pamięci następuje przez podanie z zewnątrz sygnału EA (EA=1 wybiera pamięć wewnętrzną, EA=0 - pamięć zewnętrzną). Również pamięć danych ma początkowy fragment 256 bajtów (adresy 0..00FFh) zrealizowany jako pamięć zewnętrzna i wewnętrzna. Dostęp do zewnętrznej pamięci danych umożliwiają specjalne rozkazy stosujące adresowanie 16-bitowe poprzez rejestr DPTR, lub adresowanie 8-bitowe poprzez rejestry R0 lub R1.

Wewnętrzna pamięć danych zawiera wszystkie rejestry uniwersalne, stos i obszar roboczy (adresy 0..7Fh) oraz wszystkie rejestry specjalne (adresy 80h..FFh). Osobliwością procesora 8051 jest możliwość adresowania pewnego fragmentu wewnętrznej pamięci danych z dokładnością do bitu; jest to ciągły obszar adresów 20h..2Fh (adresy bitów 0..127) oraz niektóre rejestry specjalne (adresy bitów 128..255). Bitowo można adresować 11 spośród 21 rejestrów specjalnych: ACC, B, PSW, P0, P1, P2, P3, IP, IE, TCON i SCON (tab. 1). W obszarze 80h-FFh adresy, pod którymi nie ma żadnego rejestru są niewykorzystane (przy odczycie dają wartość nieokreśloną).


FFFF

FFFF

Zewn.

1000

(PSEN=0)

0FFF

Wewn. Zewn. FF

80

SFR

00FF

(EA=1)

0000

(EA=0) 7F

00

Wewn.

0000

Zewn.

Pamięć programu

Pamięć danych

Rys. 4.3. Struktura pamięci mikrokomputera 8051

Tab. 4.1. Adresy rejestrów specjalnych (SFR) w wewnętrznej pamięci danych

Adres

Rejestr

Adresy bitów

Adres

Rejestr

Adresy bitów

Dzies. Hex. Dzies. Hex.

128 80 PO 135 – 128 144 90 P1 151 – 144 129 81 SO - 152 98 SCON 159 – 152 130 82 DPL - 153 99 SBUF - 131 83 DPH - 160 A0 P2 167 – 160 135 87 PCON - 168 A8 IE 175 – 168 136 88 TCON 143 –136 176 B0 P3 183 – 176 137 89 TMOD - 184 B8 IP 191 – 184 138 8A TL0 - 208 D0 PSW 215 – 208 139 8B TL1 - 224 E0 ACC 231 – 224 140 8C TH0 - 240 F0 B 247 – 240 141 8D TH1 -

Kodowanie rozkazów

Rozkazy są kodowane w 1, 2 lub 3 bajtach. Kod operacyjny jest zawsze zawarty w pierwszym bajcie rozkazu, następne bajty zawierają adres lub argument bezpośredni. Są cztery podstawowe sposoby wskazywania argumentu: adresacja rejestrowa, bezpośrednia pośrednia i natychmiastowa. Adresacja rejestrowa dotyczy argumentów zawartych w jednym z ośmiu rejestrów uniwersalnych aktualnego zestawu (zestaw jest określony przez pole RS w PSW). Numer rejestru (n) jest kodowany na 3 bitach


pierwszego bajta rozkazu; np. rozkaz "dodanie rejestru do akumulatora" (ADD A,Rn) ma 1-bajtowy kod

0 0 1 0 1 n

Adresacja bezpośrednia wskazuje 8-bitowy adres argumentu (dir) zawartego w wewnętrznej pamięci danych; np. rozkaz "dodanie bajta z pamięci do akumulatora" (ADD A,dir) jest kodowany na 2 bajtach:

0 0 1 0 0 1 0 1 dir

W przypadku rozkazów działających na bitach adres bezpośredni oznacza numer bitu w przestrzeni wewnętrznej pamięci danych adresowanej bitowo; np. rozkaz "przesłanie bitu (bit) do CY" (MOV C,bit) jest kodowany jako

1 0 1 0 0 0 1 0 bit

Adresacja pośrednia również wskazuje adres 8-bitowy lecz za pośrednictwem jednego z dwóch rejestrów: R0 lub R1. Zależnie od rozkazu, argumenty mogą być w pamięci zewnętrznej lub wewnętrznej. Numer rejestru pośredniczącego jest kodowany na jednym bicie kodu rozkazowego; np. rozkaz "dodanie do akumulatora bajta wskazywanego w pamięci przez rejestr i" (ADD A,@Ri) jest kodowany w 1 bajcie:

0 0 1 0 0 1 1 i

Adresacja natychmiastowa wskazuje na argument zawarty bezpośrednio w rozkazie. Argumenty bezpośrednie są 18-bitowe (data) za wyjątkiem rozkazu MOV DPTR,#data16, który ma argument 16-bitowy. Np. rozkaz "przesłanie stałej do rejestru n" (MOV Rn,#data) ma kod

0 1 1 1 1 n data

Rozkazy skokowe mają adresy względne lub bezwzględne. Adresy względne (rel) określają odległość od miejsca wskazywanego przez PC w granicach -128 .. +127 i są kodowane na 8 bitach. Adresy bezwzględne są 16-bitowe (addr) lub 11-bitowe (addr11); ta ostatnia wielkość występuje jedynie w kilku rozkazach dla zachowania zgodności z wcześniejszym modelem tego mikrokomputera 8048. Np. rozkaz "dalekiego skoku" (LJMP addr) zajmuje 3 bajty:

0 0 0 0 0 0 1 0 addr_H addr_L

natomiast rozkaz "skoku przy A=0" (JNZ rel) zajmuje 2 bajty:

0 1 1 0 0 0 0 0 rel


Lista rozkazów

Wszystkie rozkazy opisano dokładnie w tablicach 4.1 - 4.6. Oprócz standardowych symboli zastosowano tam następujące oznaczenia specyficzne dla 8051:

PM[0:65535]<7:0> pamięć programu, DM[0:255]<7:0> wewnętrzna pamięć danych, BM[0:255]<> fragment wewnętrznej pamięci danych adresowany bitowo XM[0:65535]<7:0> zewnętrzna pamięć danych, PC, A, B, SP, DPTR rejestry 8051, CY, AC znaczniki stanu 8051 (w PSW), data 8-bitowa dana bezpośrednia, data16 16-bitowa dana bezpośrednia, addr16 16-bitowy adres bezpośredni, addr11 11-bitowy adres bezpośredni,

adH 3-bitowa bardziej znacząca część addr11 dir 8-bitowy adres bezpośredni, rel 8-bitowy adres względny, bit 8-bitowy adres bitu w BM, n 3-bitowy numer rejestru, i 1-bitowy numer rejestru adresacji pośredniej.

"Kod op." podaje dwójkową postać pierwszego bajta rozkazu, w rubryce "Długość" podano długość rozkazu w bajtach. Duża liczba rozkazów przy stosunkowo niewielkiej różnorodności spełnianych funkcji wynika z zastosowania osobnych kodów operacyjnych do każdego sposobu adresowania argumentów.

Tab. 4.2. Rozkazy przesłań

Oznaczenie

Kod op.

Długość

Działanie

MOV A, Rn 11101 n 1 A Rn MOV A, dir 11100101 2 A DM[dir] MOV A, @Ri 1110011i 1 A DM[Ri] MOV A, #data 01110100 2 A data MOV Rn, A 11111 n 1 Rn A MOV Rn, dir 10101 n 2 Rn DM[dir] MOV Rn, #data 01111 n 2 Rn data MOV dir, A 11110101 2 DM[dir] A MOV dir, Rn 10001 n 2 DM[dir] Rn MOV dir1, dir2 10000101 3 DM[dir1] DM[dir2] MOV dir, @Ri 1000011i 2 DM[dir] DM[Ri] MOV dir, #data 01110101 3 DM[dir] data MOV @Ri, A 1111011i 1 DM[Ri] A MOV @Ri, dir 1010011i 2 DM[Ri] DM[dir] MOV @Ri, #data 0111011i 2 DM[Ri] data MOV DPTR, #data16 10010000 3 DPTR data16

MOVC A, @A+DPTR 10010011 1 A PM[A+DPTR] MOVC A, @A+PC 10000011 1 A PM[A+PC] MOVX A, @Ri 1110001i 1 A XM[Ri] MOVX A, @DPTR 11100000 1 A XM[DPTR] MOVX @Ri, A 1111001i 1 XM[Ri] A MOVX @DPTR, A 11110000 1 XM[DPTR] A

POP dir 11010000 2 DM[dir] DM[SP]; next SP SP-1 PUSH dir 11000000 2 SP SP+1; next DM[SP] DM[dir]

XCH A, Rn 11001 n 1 A Rn XCH A, dir 11000000 2 A DM[dir] XCH A, @Ri 1100011i 1 A DM[Ri] XCHD A, @Ri 1101011i 1 A<3:0> DM[Ri]<3:0>


Rozkazy przesłań

Rozkazy przesłań (tab. 4.2) dotyczą głównie wymiany bajtów między rejestrami uniwersalnymi, rejestrami specjalnymi (SFR) i wewnętrzną pamięcią danych.

W grupie tej znajdują się tez 4 rozkazy MOVX (move external RAM) - jedyne, które umożliwiają kontakt procesora z zewnętrzną pamięcią danych. Z kolei, rozkazy MOVC (move code) przesyłają do akumulatora bajty z pamięci programu - np. stałe umieszczone w programie. Rozkaz XCHD (exchange digit) może być przydatny w programowaniu działań arytmetyki dziesiętnej (BCD), gdyż przenosi tylko 4 mniej znaczące bity argumentów.

Przy przesłaniach na stos (PUSH) lub ze stosu (POP) argument jest pobierany lub przekazywany z/do wewnętrznej pamięci danych a stos rośnie w kierunku adresów rosnących.

Na uwagę zasługuje dwuadresowy rozkaz MOV dir1,dir2 umożliwiający w jednym cyklu rozkazowym przesłanie bajta między dwoma dowolnymi miejscami wewnętrznej pamięci danych.


Rozkazy arytmetyczne udostępniają cztery podstawowe działania na różnych kombinacjach argumentów 8-bitowych. Dodawanie i odejmowanie z uwzględnieniem przeniesień (CY) umożliwia programowanie obliczeń na słowach wielobajtowych.

Arytmetyka dziesiętna (w kodzie BCD) wymaga stosowania rozkazu korekcji - DA; rozkaz ten koryguje wynik dodawania binarnego 2-cyfrowych argumentów dziesiętnych (korekcja „+6”).

Tab. 4.3. Rozkazy arytmetyczne

Oznaczenie

Kod op.

Długość

Działanie

ADD A, Rn 00101 n 1 A A + Rn ADD A, dir 00100101 2 A A + DM[dir] ADD A, @Ri 0010011i 1 A A + DM[Ri] ADD A, #data 00100100 2 A A + data ADDC A, Rn 00111 n 1 A A + Rn + CY ADDC A, dir 00110101 2 A A + DM[dir] + CY ADDC A, @Ri 0011011i 1 A A + DM[Ri] + CY ADDC A, #data 00110100 2 A A + data + CY

SUBB A, Rn 10011 n 1 A A - Rn – CY SUBB A, dir 10010101 2 A A - DM[dir] – CY SUBB A, @Ri 1001011i 1 A A - DM[Ri] – CY SUBB A, #data 10010100 2 A A - data – CY

MUL AB 10100100 1 A^B A*B DIV AB 10000100 1 A A/B

INC A 00000100 1 A A + 1 INC Rn 00001 n 1 Rn Rn + 1 INC dir 00000101 2 DM[dir] DM[dir] + 1 INC @Ri 0000011i 1 DM[Ri] DM[Ri] + 1

DEC A 00010100 1 A A – 1 DEC Rn 00011 n 1 Rn Rn – 1 DEC dir 00010101 2 DM[dir] DM[dir] – 1 DEC @Ri 0001011i 1 DM[Ri] DM[Ri] – 1

INC DPTR 10100011 1 DPTR DPTR + 1

DA A 11010100 1 ((A<3:0> gtr 9) or AC) => A A + 6; next

((A<7:4> gtr 9) or CY) => A<7:4> A<7:4> + 6

Rozkazy logiczne

Rozkazy działań logicznych obejmują alternatywę, koniunkcję i różnicę symetryczną argumentów 8-bitowych traktowanych jako łańcuchy binarne. Przesunięcia są tylko cykliczne i dotyczą wyłącznie zawartości akumulatora; rozkaz wymiany tetrad (SWAP) może być przydatny w działaniach na liczbach dziesiętnych.


Tab 4.4. Rozkazy logiczne.

Oznaczenie

Kod op.

Długość

Działanie

ANL A, Rn 01011 n 1 A A and Rn ANL A, dir 01010101 2 A A and DM[dir] ANL A, @Ri 0101011i 1 A A and DM[Ri] ANL A, #data 01010100 2 A A and data ANL dir, A 01010010 2 DM[dir] DM[dir] and A ANL dir, #data 01010011 3 DM[dir] DM[dir] and data

ORL A, Rn 01001 n 1 A A or Rn ORL A, dir 01000101 2 A A or DM[dir] ORL A, @Ri 0100011i 1 A A or DM[Ri] ORL A, #data 01000100 2 A A or data ORL dir, A 01000010 2 DM[dir] DM[dir] or A ORL dir, #data 01000011 3 DM[dir] DM[dir] or data

XRL A, Rn 01101 n 1 A A xor Rn XRL A, dir 01100101 2 A A xor DM[dir] XRL A, @Ri 0110011i 1 A A xor DM[Ri] XRL A, #data 01100100 2 A A xor data XRL dir, A 01100010 2 DM[dir] DM[dir] xor A XRL dir, #data 01100011 3 DM[dir] DM[dir] xor data

CLR A 11100100 1 A 0 CPL A 11110100 1 A not A RL A 00100011 1 A rol A RLC A 00110011 1 A^CY rol A^CY RR A 00000011 1 A ror A RRC A 00010011 1 A^CY ror A^CY SWAP A 11000100 1 A<7:4> A<3:0>

Procesor boolowski

Osobliwością mikrokomputera 8051 jest tzw. procesor boolowski realizujący działania na pojedynczych bitach adresowanych w wyróżnionym fragmencie wewnętrznej pamięci danych. Akumulatorem tego procesora jest znacznik przeniesienia CY w słowie stanu PSW. Działania na bitach są szczególnie przydatne w zastosowaniach 8051 do sterowania procesami.

Tab. 4.5. Rozkazy działające na bitach.

Oznaczenie

Kod op.

Długość

Działanie

CLR C 11000011 1 CY 0 SETB C 11010011 1 CY 1 CPL C 10110011 1 CY not CY

CLR bit 11000010 2 BM[bit] 0 SETB bit 11010010 2 BM[bit] 1 CPL bit 10110010 2 BM[bit] not BM[bit]

ANL C, bit 10000010 2 CY CY and BM[bit] ANL C, /bit 10110000 2 CY CY and (not BM[bit] ) ORL C, bit 01110010 2 CY CY or BM[bit] ORL C, /bit 10100000 2 CY CY or (not BM[bit] )

MOV C, bit 10100010 2 CY BM[bit] MOV bit, C 10010010 2 BM[bit] CY

Rozkazy sterujące

Rozkazy sterujące przebiegiem programu zawierają dużą liczbę skoków warunkowych, w tym szereg rozkazów badających wskazane bity pamięci danych. Skoki warunkowe są względne (w zakresie -128 .. +127 bajtów). Absolutny jest skok bezwarunkowy LJMP (long jump) umożliwiający osiągnięcie


dowolnego adresu pamięci programu. Podprogramy są wywoływane bezwarunkowo rozkazem LCALL z zastosowaniem stosu do przechowania bieżącego licznika rozkazów; rozkaz powrotu z podprogramu RET odtwarza poprzednią zawartość PC. Rozkazy ACALL i AJMP z adresami 11-bitowymi są pozostawione dla zachowania zgodności z poprzednim modelem tego mikrokomputera - 8048.

Tab. 4.6. Rozkazy sterujące

Oznaczenie

Kod op.

Długość

Działanie

AJMP addr11 adH00001 2 PC addr11

LJMP addr16 00000010 3 PC addr16

SJMP rel 10000000 2 PC PC + rel

JMP @A+DPTR 01110011 1 PC DPTR + A

JZ rel 01100000 2 (A = 0) => PC PC + rel

JNZ rel 01110000 2 (A 0) => PC PC + rel

CJNE A, dir, rel 10110101 3 (DM[dir] A) => PC PC + rel

CJNE A, #data, rel 10110100 3 (data A) => PC PC + rel

CJNE Rn, #data, rel 10111 n 3 (data Rn) => PC PC + rel

CJNE @Ri, #data, rel 1011011i 3 (data DM[Ri]) => PC PC + rel

DJNZ Rn, rel 11011 n 2 Rn Rn – 1; next (Rn 0) => PC PC + rel

DJNZ dir, rel 11010101 3 DM[dir] DM[dir] – 1; next

(DM[dir] 0) => PC PC + rel

JC rel 01000000 2 CY => PC PC + rel

JNC rel 01010000 2 not CY => PC PC + rel

JB bit, rel 00100000 3 BM[bit] => PC PC + rel

JNB bit, rel 00110000 3 not BM[bit] => PC PC + rel

JBC bit, rel 00010000 3 BM[bit] => PC PC + rel; next BM[bit] 0

ACALL addr11 adH10001 2 SP SP + 1; next DM[SP] PC<15:8>; next

SP SP + 1; next DM[SP] PC<7:0>; next

PC addr11

LCALL addr16 00010010 3 SP SP + 1; next DM[SP] PC<15:8>; next

SP SP + 1; next DM[SP] PC<7:0>; next

PC addr16

RET 00100010 1 PC<7:0> DM[SP]; next SP SP – 1; next

PC<15:8> DM[SP]; next SP SP – 1

RETI 00110010 1 PC<7:0> DM[SP]; next SP SP – 1; next

PC<15:8> DM[SP]; next SP SP – 1

NOP 000000000 1

Przerwania

W 8051 jest 5 źródeł przerwań:

dwa sygnały zewnętrzne podawane na wejścia INT0 i INT1 portu P3,

dwa sygnały przepełnienia liczników (TF0 i TF1) oraz

sygnał odebrania (RI) lub wysłania (TI) znaku podawany z układu transmisji szeregowej (UART).

Charakter sygnału przerywającego na wejściach INTi (poziom lub zbocze) jest programowany w rejestrze TCON - maski przerwań.


7 6 5 4 3 2 1 0

EA ES ET1 EX1 ET0 EX0

TF1 TF0

Ogólna maska przerwań

Indywidualne maski

przerwań:

UART INT1 INT0

Rys. 4.4. Rejestr maskowania przerwań IE.

Każde zgłoszenie przerwania może być maskowane indywidualnie przez ustawienie odpowiednich bitów w rejestrze IE; w rejestrze tym można również ustawić ogólne maskowanie wszystkich przerwań. Przez ustawienie odpowiednich bitów w rejestrze IP można przypisać każde źródło przerwania do grupy o wysokoim priorytecie lub do grupy o niskim priorytecie. Przerwania o niskim priorytecie nie mogą przerywać obsługi przerwań o wysokim priorytecie. Obsługa przerwania nie może też być przerwana przez zgłoszenie o tym samym priorytecie. W obrębie grupy obowiązuje następująca kolejność przyjęcia zgłoszeń równoczesnych: INT0, TF0, INT1, TF1, UART.

7 6 5 4 3 2 1 0

PS PT1 PX1 PT0 PX0

TF1 TF0

UART INT1 INT0

Rys. 4.5. Rejestr priorytetów przerwań IP.

Przyjęcie przerwania powoduje załadowanie na stos licznika rozkazów (PC) i wpisanie do PC nowej wartości („wektora”) określającej początek programu obsługi (tab. 7.). Obsługa przerwania powinna się kończyć rozkazem RETI, który odtwarza ze stosu poprzednią zawartość PC umożliwiając kontynuowanie przerwanego programu.

Tab. 4.7. Adresy początkowe obsługi przerwań.

Źródło przerwania Adres

INT0 0003h TF0 000Bh INT1 0013h TF1 001Bh

RI lub TI 0023h


Już ledwo sapie, już ledwo zipie,

A jeszcze palacz węgiel w nią sypie.

Julian Tuwim

Intel x86 - architektura IA-16 i IA-32

Historia

Rodzina x86 przeszła od swego powstania znaczną ewolucję, w której ważnym zdarzeniem było wprowadzenie w modelu 80286 dwóch trybów pracy: tzw. „rzeczywistego” (real mode) i „chronionego” lub „wirtualnego” (virtual protected mode), co w istocie było równoważne realizacji dwóch różnych architektur w tym samym mikroprocesorze z zachowaniem kompatybilności w stosunku do poprzednich, starszych modeli. Poczynając od następnego modelu, oznaczonego 386, nowy tryb chroniony udostępniał już procesor w pełni 32-bitowy z możliwością adresowania 4G bajtów ( 1G = 2

30

109) i pamięcią wirtualną o teoretycznej wielkości 64T bajtów (1T = 2

40 10

12). W kolejnym modelu,

486, zachowano architekturę 386 integrując w jednym układzie scalonym oprócz procesora centralnego również jednostkę zmiennoprzecinkową (poprzednio wykonywaną jako osobny tzw. koprocesor arytmetyczny) oraz układ zarządzania pamięcią.

Wprowadzone później procesory Pentium (ostatni model, ze stycznia 1999, nosi nazwę Pentium III) zachowują zasadniczo architekturę 486 a różnią się wydajnością zwiększaną w każdej nowej edycji dzięki zmianom wewnętrznej organizacji logicznej i stosowaniem coraz szybszych układów. Pewne rozszerzenie listy rozkazów wprowadzono w procesorze Pentium MMX (Multi Media eXtension) - dodając nowe rozkazy pozwalające szybciej realizować algorytmy związane z przetwarzaniem danych graficznych. W procesorach Pentium III wprowadzono grupę 70 nowych rozkazów SSE (Streaming SIMD extension, początkowo określanych jako MMX2 lub KNI - Katmai New Instruction ) działających na danych zmiennoprzecinkowych i przeznaczonych do obsługi grafiki 3D. Procesory serii Pentium są określane jako superskalarne, co oznacza, że mogą przetwarzać jednocześnie kilka strumieni rozkazów przy czym fazy realizacji kolejnych rozkazów w każdym strumieniu nakładają się. W efekcie procesory superskalarne mogą przetwarzać więcej niż jeden rozkaz w czasie jednego cyklu zegara.

Istotna zmiana organizacji logicznej nastąpiła w Pentium Pro; w procesorze tym (i późniejszych, z wyjątkiem Pentium MMX) złożone instrukcje x86 są przed wykonaniem zamieniane na zestawy tzw.

„mikrooperacji” (Ops) mających charakter rozkazów typu RISC. Mikrooperacje są wykonywane w miarę dostępnych danych (Out-of-Order ) współbieżnie przez kilka jednostek operacyjnych na zawartości wewnętrznych rejestrów roboczych a następnie wyniki są umieszczane w rejestrach


procesora. Mimo wewnętrznego „rdzenia” RISC, na zewnątrz procesory zachowują architekturę CISC - zgodną z rodziną x86, określaną czasem jako IA-32 (Intel Architecture). Odpowiednio IA-64 oznacza nową architekturę procesorów 64-bitowych planowanych po roku 2000 (procesory o nazwach roboczych Merced, McKinley).

Twórcami architektury IA -16 (procesory 8086 i 8088) byli Stephen Morse i Bruce Ravenel, natomiast IA-32 - John Crawford i Patric Gelsinger.

Dwie architektury

Poczynając od modelu 286 każdy procesor rodziny x86 może pracować w jednym z dwóch, wybieranych programowo, trybów:

trybie rzeczywistym (real address mode),

trybie chronionym (protected virtual address mode).

Tryby te różnią się głównie stosowanym modelem pamięci, co pociąga za sobą konsekwencje w postaci różnych sposobów adresowania dostępnych w tych trybach, różnych rozmiarów adresów - ogólnie: różnego kodowania i różnych możliwości operacyjnych nawet tych samych rozkazów.

W każdym trybie możliwa jest adresacja 16-bitowa i adresacja 32-bitowa. Adresacja 16-bitowa jest traktowana jako domyślna w trybie rzeczywistym a adresacja 32-bitowa jest domyślna w trybie chronionym.

Adresy logiczne, generowane przez program, są 2-wymiarowe - składają się z selektora segmentu (selector) i przemieszczenia w segmencie (offset). W czasie działania procesora selektor jest zapisany w jednym z sześciu 16-bitowych rejestrów segmentowych, natomiast przemieszczenie (16- lub 32-bitowe) jest wyliczane na podstawie zastosowanego w rozkazie sposobu adresacji. Przemieszczenie jest nazywane adresem efektywnym (EA, effective address).

W trybie rzeczywistym selektor wskazuje bezpośrednio adres bazowy (początkowy) segmentu, co pozwala wyznaczyć 20-bitowy adres rzeczywisty:

adres_ 20 = 16 x selektor_16 + przemieszczenie_16.

Wszystkie segmenty są w tym trybie 64K-bajtowe i mieszczą się w przestrzeni 1M-bajtowej.

W trybie chronionym selektor wskazuje 8-bajtowy rekord zwany deskryptorem segmentu i dopiero w tym deskryptorze zapisana jest 32-bitowa baza, 20-bitowa wielkość segmentu i inne atrybuty (m.in. sposób ochrony). Baza i przemieszczenie wyznaczają 32-bitowy tzw. adres liniowy:

adres_liniowy_32 = baza_32 + przemieszczenie_32.

Segmenty w trybie chronionym mogą mieć różną wielkość (1B - 1MB jeżeli ziarnistość jest 1B albo 4KB - 4GB z ziarnistością 4KB) i są umieszczone w przestrzeni 4G-bajtowej.

W systemach stosujących stronicowanie, adres liniowy przekształcany jest jeszcze w adres fizyczny, również 32-bitowy.

O sposobie interpretacji kodu programu decyduje bit D (default) w deskryptorze segmentu kodu (jego selektor mieści się w rejestrze CS, code segment); bit ten określa domyślną wielkość adresów (i związane z nią dopuszczalne sposoby adresowania) oraz domyślną wielkość argumentów:

D = 1 - adresacja 32-bitowa, argumenty 8- lub 32-bitowe (bajt, słowo podwójne),

D = 0 - adresacja 16-bitowa, argumenty 8- lub 16-bitowe (bajt, słowo),

Adresacja domyślna w danym trybie może być zmieniona (odwrócona) za pomocą tzw. przedrostków (prefix). Są dwa, wzajemnie niezależne, przedrostki, które można stosować w każdym rozkazie programu - przedrostek rozmiaru adresu i przedrostek rozmiaru argumentu, przy czym dopuszczalne są wszystkie 4 kombinacje rozmiarów adresów i argumentów.

Po włączeniu (po sygnale RESET) procesor znajduje się w trybie rzeczywistym.


Procesory Intel x86

Typ

Rok Liczba tranzyst.

Pamięć “cache”

(KB)

Koprocesor zmp.

Nowości

8086 1978 29 000 nie 8087 Słowo 16-bitowe, kompatybilny z 8088

80186 1981 100 000 nie 187 Zintegrowane układy sterujące.

80286 1982 130 000 nie 287 Tryb rzeczywisty i chroniony, adresy 24-bitowe

386 1986 275 000 8 zewn. 387 Słowo 32-bitowe, zewnętrzna pamięć cache

486 1989 1 185 000 8 Wewnętrzna pamięć cache wspólna dla danych i kodu.

Pentium 1993 3 100 000 2x8 Sterowanie superskalarne (2 jednostki stp.)

Pentium Pro 1995 5 500 000 2x8+256/512 Jednostka zmienno-

Wewnętrzny RISC, pamięć cache drugiego poziomu (L2)

Pentium MMX 1997 4 500 000 2x16 przecinkowa Rozkazy MMX korzystające z rejestrów FPU

Pentium II 1997 7 500 000 2x16+ (512) (FPU) Zegar > 200MHz, cache L2 osobno

Pentium III 1999 Rozkazy SSE niezależne od FPU

Rejestry

Procesor dysponuje 8 rejestrami danych 8-bitowych oraz 8 rejestrami danych 16-bitowych lub 32-bitowych . Wybór rejestrów 16-bitowych lub odpowiednich rejestrów 32-bitowych (E__, extended) zależy od obowiązującego rozmiaru argumentu. Rejestry 8-bitowe stanowią fragmenty rejestrów 16-bitowych, a te z kolei, fragmenty rejestrów 32-bitowych (rys. ?1).

Analogicznie traktowane są rejestry stosowane przy obliczaniu adresu efektywnego argumentów: dwa rejestry indeksowe (SI,DI - source idex, destination index), rejestr wskaźnika stosu (SP, stack pointer), rejestr bazowy (BP, base pointer) i wskaźnik następnego rozkazu (IP, instruction pointer). Rejestry adresowe zawsze zawierają tylko przemieszczenie adresu (offset) w obrębie segmentu.

Selektory aktualnych segmentów są zawsze 16-bitowe i są umieszczone w rejestrach segmentowych CS, SS, DS, ES, FS I GS. Niektóre segmenty są domyślnie skojarzone ze źródłem przemieszczenia, np. IP z CS (code segment), SP z SS (stack segment), adresy danych z DS (data segment), w operacjach łańcuchowych SI z DS a DI z ES. Standardowe przypisania rejestrów segmentowych mogą być indywidualnie zmieniane za pomocą przedrostka zmiany segmentu (segment override prefix).


32-bitowe: 31

15

7 0

16-bitowe:

EAX AH AL AX

EBX BH BL BX Rejestry

ECX CH CL CX danych

EDX DH DL DX

ESI SI Rejestry

EDI DI indeksowe

EBP BP Rejestr bazowy

ESP SP Wskaźnik stosu

32-bitowe: 31 15 0

EIP IP Wskaźnik (licznik) rozkazów

EFLAGS FLAGS Znaczniki (słowo stanu)

15 0

CS

SS Rejestry

DS segmentowe

ES

FS

GS

Rys.5.1. Główne rejestry procesora.

Rejestr znaczników FLAGS (EFLAGS) przechowuje znaczniki stanu wykonanej operacji, informację sterującą przebiegiem wykonania rozkazów oraz informacje systemowe (rys.5.2).

15 14 13 12 11 10 9 8 7 6 5 4 3 2 1 0

0 NT IOPL OF DF IF TF SF ZF 0 AF 0 PF 1 CF

31 30 29 28 27 26 25 24 23 22 21 20 19 18 17 16

0 0 0 0 0 0 0 0 0 0 ID VIP VIF AC VM RF

Rys. 5.2. Znaczniki w rejestrze EFLAGS:

Znaczniki stanu operacji :

CF - przeniesienie (z najbardziej znaczącego bitu, czyli bitu <7>, <15> lub <31>) PF - parzystość (dotyczy tylko bitów <7:0> wyniku) AF - przeniesienie pomocnicze (między bitem <3> i <4>) ZF - wynik zerowy SF - znak wyniku OF - nadmiar stałoprzecinkowy

Znaczniki sterujące:

TF - pułapka (praca krokowa) IF - maska przerwań zewnętrznych DF - kierunek przeglądania pamięci w operacjach łańcuchowych


Znaczniki systemowe:

IOPL - poziom ochrony we-wy NT - zadanie zagnieżdżone RF - wznowienie zadania VM - tryb wirtualny 8086 AC - wyrównanie adresów VIF - przerwanie wirtualne VIP - przerwanie wirtualne nie obsłużone ID - identyfikacja procesora.

Oprócz wymienionych, w procesorach są rejestry sterujące(CR0 .. CR4), rejestry związane z układem zarządzania pamięcią (GDTR, IDTR, TR, LDTR) i rejestry uruchomieniowe (DR0 .. DR7).

Osobny zestaw rejestrów danych, rejestrów stanu i rejestrów sterujących ma jednostka zmiennoprzecinkowa (koprocesor w procesorach starszych niż 486). Osiem 80-bitowych rejestrów danych jednostki zmiennoprzecinkowej tworzy stos obliczeniowy.

Te same rejestry - dokładnie: ich 64-bitowe fragmenty - są zamiennie używane przez rozkazy MMX do działań na grupach bajtów w procesorach wyposażonych w to rozszerzenie listy rozkazów.

Formaty rozkazów

Rozkaz jest łańcuchem, co najmniej 1-bajtowym, o strukturze:

Przedrostki

Kod operacji

Pole adresowe

Przesunięcie

Argument bezpośredni

0,1,2,3,4

1,2

0,1,2

0,1,2,4

0,1,2,4

Liczba bajtów

Przedrostki

Przedrostek jest 8-bitowym kodem zmieniającym domyślne działanie następującego po nim rozkazu. Są 4 grupy przedrostków; w danym rozkazie może wystąpić tylko jeden przedrostek z każdej grupy:

Przedrostki operacyjne - powtórzenia (repeat following string operation); dotyczą rozkazów łańcuchowych i powodują

wielokrotne wykonywanie następującego rozkazu aż do wyzerowania licznika (REP) ustawionego w rejestrze CX (ECX) lub do uzyskania ZF=0 (REPZ) albo ZF=1 (REPNZ); kody tych przedrostków: REP - F2h, REPZ - F3h, REPNZ - F2h,

- blokada (LOCK, assert LOCK signal); przedrostek stosowany w systemach wieloprocesorowych do blokowania wspólnej pamięci; kod: - F0h

Przedrostki zmiany segmentu (override prefix ) zmieniają domyślny segment; kody: CS - 2Ch, DS - 3Ch, ES - 26h, FS - 64h, GS - 65h, SS - 36h

Przedrostek rozmiaru argumentu (operand size toggle, kod: 66h); zmienia domyślny rozmiar argumentu z 16 na 32 bity i odwrotnie.

Przedrostek rozmiaru adresu (address size toggle, kod: 67h); zmienia domyślny rozmiar adresu z 16 na 32 bity i odwrotnie.

Kod operacji

Większość rozkazów ma kody operacyjne jednobajtowe, choć niektóre wykorzystują jako rozszerzenie kodu dodatkowo 3 bity z pola adresowego (pole REG); jest tak np. w rozkazach zmiennoprzecinkowych. Kody dwubajtowe mają rozkazy dodane w późniejszych wersjach procesora.

Jedna operacja (identyfikowana tym samym mnemonikiem na poziomie języka asemblera) może mieć wiele różnych kodów operacyjnych - zależnie od typu argumentów (rejestr, pamięć, stała) i od miejsca umieszczenia wyniku. Istnieją też specjalne kody (short form) dla operacji na zawartości rejestru akumulatora (jego rolę pełni AL, AX lub EAX - zależnie od formatu danych).

W większości kodów, w których to ma sens, bit <0>, oznaczany jako bit w, wskazuje wielkość argumentów:


w = 0 - argumenty „krótkie”, 8-bitowe,

w = 1 - argumenty „długie”, 16- lub 32-bitowe (zależnie od ustawienia w deskryptorze segmentu).

Podobnie bit <1>, oznaczany jako d, określa miejsce wyniku operacji dwuargumentowej:

d = 0 - wynik jest przesyłany na miejsce argumentu wskazywanego w polu R/M,

d = 1 - wynik jest przesyłany na miejsce argumentu wskazywanego w polu REG.

W rozkazach z argumentem bezpośrednim (imm), bit <1> - oznaczany wówczas jako s - określa postać argumentu w słowie rozkazowym:

s = 0 - argument zapisany na 16 lub 32 bitach,

s = 1 - argument zapisany na 8 bitach, w czasie wykonywania działań rozszerzany z zachowaniem znaku (sign extended).

Ilustracja wymienionych reguł mogą być kody operacyjne rozkazu ADD (dodawanie stałoprzecinkowe):

Działanie Kod op.

r r + r/m 0000 001w

r/m r + r/m 0000 000w

r/m r/m + imm16/32 1000 000w (REG=000)

r/m r/m + imm8 1000 001w (REG=000)

ac ac + imm 0000 010w (brak pola adresowego)

Oznaczenia: ac - akumulator (AL, AX lub EAX) imm16/32 - argument bezpośredni (stała) 16-bitowy lub 32-bitowy imm8 - argument bezpośredni (stała) 8-bitowy r - rejestr (kodowany w polu adresowym REG), r/m - pamięć lub rejestr (kodowanie w polu adresowym R/M i MOD)

Pole adresowe

Zależnie od trybu adresacji (16- lub 32- bitowej) pole adresowe ma jeden lub dwa bajty. Ze względu na różny sposób interpretacji tego pola w każdym z wymienionych trybów, omówiono je osobno.

Pole adresowe nie występuje w rozkazach bezargumentowych i w rozkazach z argumentami implikowanymi przez kod operacji.

Pole adresowe przy adresacji 16-bitowej

Struktura pola adresowego:

7 6 5 4 3 2 1 0

MOD REG R/M

Argument kodowany w polu REG może być tylko

w rejestrze 8- lub 16-bitowym (albo 32-bitowym, gdy jest prefiks operand size) - długość zależy od bitu w w kodzie operacyjnym)

Argument kodowany w polu MOD-R/M może być:

w rejestrze 8- lub 16-bitowym (albo 32-bitowym, gdy jest prefiks operand size) - długość zależy od bitu w w kodzie operacyjnym)

w pamięci adresowanej bezpośrednio M[d16] poprzez rejestr - pośrednio M[rg1] - względnie M[rg2+d]


- indeksowo M[rb+ri] - bazowo z indeksacją M[rb+ri+d]

Przesunięcie d, traktowane jako liczba ze znakiem, może być 8-bitowe (d8) lub 16-bitowe (d16).

Możliwe użycie rejestrów: rg1 = {SI,DI,BX} rg2 = {SI,DI,BX,BP} rb = {BX,BP} ri = {SI,DI}

Kodowanie rejestru zawierającego argument kodowany w polu REG (adresacja 16-bitowa)

REG w=0 w=1 (default)

w=1 (prefix)

0 AL AX EAX

1 CL CX ECX

2 DL DX EDX

3 BL BX EBX

4 AH SP ESP

5 CH BP EBP

6 DH SI ESI

7 BH DI EDI

Kodowanie rejestru zawierającego argument kodowany w polu MOD-R/M:

R/M (MOD=3)

w=0 w=1 (default)

w=1 (prefix)

0 AL AX EAX

1 CL CX ECX

2 DL DX EDX

3 BL BX EBX

4 AH SP ESP

5 CH BP EBP

6 DH SI ESI

7 BH DI EDI

Kodowanie sposobu adresacji argumentu w pamięci (adresacja 16-bitowa)

MOD R/M

M[d16] 0 6

M[rg1] 0 4,5,7

M[rg2+d] 1,2 4,5,6,7

M[rb+ri] 0 0,1,2,3

M[rb+ri+d] 1,2 0,1,2,3

Kodowanie przesunięcia (adresacja 16-bitowa)

MOD d

0 -

1 d8

2 d16

3 -


Kodowanie rejestrów używanych w adresacji argumentu MOD-R/M (adresacja 16-bitowa)

R/M

rg1 rg2 rb ri

0 - - BX SI

1 - - BX DI

2 - - BP SI

3 - - BP DI

4 SI SI - -

5 DI DI - -

6 - BX - -

7 BX BP - -

Pole adresowe przy adresacji 32-bitowej

Struktura pola adresowego (1-bajtowego) dla R/M100:

7 6 5 4 3 2 1 0

MOD REG R/M

Struktura pola adresowego (2-bajtowego) dla R/M=100:

7 6 5 4 3 2 1 0 7 6 5 4 3 2 1 0

MOD REG 1 0 0 SS INDEX BASE

Argument kodowany w polu REG może być tylko

w rejestrze 8- lub 32-bitowym (albo 16-bitowym, gdy jest prefiks operand size) - długość zależy od bitu w w kodzie operacyjnym.

Argument kodowany w polu MOD-SS-INDEX-BASE może być:

w rejestrze 8- lub 32-bitowym (albo16-bitowym, gdy jest prefiks operand size) - długość zależy od bitu w w kodzie operacyjnym,

w pamięci adresowanej bezpośrednio M[d32] (kodowanie: MOD=00, R/M=101) bezpośrednio z indeksacją M[d32+s*rx] poprzez rejestr - pośrednio M[r1] - względnie M[r2+disp] - pośrednio z indeksacją M[r3+s*rx] - względnie z indeksacją M[r4+s*rx+disp]

Przesunięcie disp może być 8-bitowe (d8) lub 32-bitowe (d32), współczynnik skali s może być równy 1,2,4 lub 8.

Kodowanie rejestru zawierającego argument kodowany w polu REG (adresacja 32-bitowa)

REG w=0 w=1 (prefix)

w=1 (default)

0 AL AX EAX

1 CL CX ECX

2 DL DX EDX

3 BL BX EBX

4 AH SP ESP

5 CH BP EBP

6 DH SI ESI

7 BH DI EDI


Kodowanie rejestru zawierającego argument kodowany w polu MOD-R/M (adresacja 32-bitowa)

R/M (MOD=0)

w=0 w=1 (prefix)

w=1 (default)

0 AL AX EAX

1 CL CX ECX

2 DL DX EDX

3 BL BX EBX

4 AH SP ESP

5 CH BP EBP

6 DH SI ESI

7 BH DI EDI

Kodowanie sposobu adresacji argumentu w pamięci (adresacja 32-bitowa)

MOD R/M BASE

M[d32] 0 5 -

M[d32+s*rx] 0 4 5

M[r1] 0 1-3,5-7 -

M[r2+disp] 1,2 1-3,5-7 -

M[r3+s*rx] 0 4 1-4,6,7

M[r4+s*r3+disp] 1,2 4 0-7

Kodowanie przesunięcia (adresacja 32-bitowa)

MOD disp

0 -

1 d8

2 d32

3 -

Kodowanie współczynnika skali (adresacja 32-bitowa)

SS s

0 1 2 3

1 2 4 8

Kodowanie rejestru indeksowego (adresacja 32-bitowa)

INDEX rx

0 1 2 3 4 5 6 7

EAX ECX EDX EBX

- EBP ESI EDI


Kodowanie rejestrów używanych w adresacji argumentu MOD-R/M (adresacja 32-bitowa)

R/M r1 r2 BASE r3 r4

0 EAX EAX 0 EAX EAX

1 ECX ECX 1 ECX ECX

2 EDX EDX 2 EDX EDX

3 EBX EBX 3 EBX EBX

4 - - 4 ESP ESP

5 - EBP 5 - EBP

6 ESI ESI 6 ESI ESI

7 EDI EDU 7 EDI EDI

Pole przesunięcia

W rozkazach, które tego wymagają, adres względny czyli przesunięcie (displacement) jest umieszczany bezpośrednio za polem adresowym. Przesunięcie może być 1-, 2- lub 4-bajtowe, przy czym słowa i słowa podwójne są zapisywane według zasady little-endian - zaczynając od bajta mniej znaczącego.

Pole argumentu bezpośredniego

W rozkazach z argumentem bezpośrednio danym w rozkazie (tzw. argument natychmiastowy, immediate) jest on umieszczany za polem przesunięcia. Występowanie argumentu bezpośredniego i jego długość (8 bitów lub 16/32 bity) są implikowane przez kod operacji.

Argumenty 2- lub 4-bajtowe są zapisywane według zasady little-endian - zaczynając od bajta mniej znaczącego.


Przykłady budowy słowa rozkazowego

Dla ilustracji złożoności kodowania rozkazów przedstawiono, dla adresacji 16-bitowej, kilka wariantów rozkazu dodawania (ADD) z różnymi argumentami (kod operacji czcionką pogrubioną, przesunięcie - kursywą, stałe - podkreślone):

Argument REG

Argument MOD-R/M

Miejsce wyniku Kod (hex) Uwagi

AH CL CL 00 E1 Argumenty bajtowe

CL AH CL 02 CC Zamiana miejsc, operacja taka jak poprzednia

BX M[2345] M[2345] 01 1E 45 23 Argumenty słowowe

BL M[4567] M[5678] 00 1E 78 56 Argumenty bajtowe

AX M[DI+1234] M[DI+1234] 01 85 34 12 Wynik w pamięci

AX M[DI+1234] AX 03 85 34 12 Wynik w rejestrze

BX M[DI+5A] BX 03 5D 5A Argumenty słowowe, przesunięcie 8-bitowe

Stała = ABCDh M[SI+6543] M[SI+6543] 81 84 43 65 CD AB Stała i przesuniecie 16-bitowe

AX Stała = ABCDh AX 05 CD AB Działanie na zawartości akumulatora

CX Stała = 2Eh CX 83 C1 2E Rejestr 16-bitowy, stała 8-bitowa

Formaty danych

Argumentami operacji mogą być:

liczby dwójkowe całkowite w kodzie uzupełnieniowym U2 (8-, 16- i 32-bitowe),

liczby dwójkowe zmiennopozozycyjne (32- , 64- i 80-bitowe),

liczby dziesiętne spakowane (18-cyfrowe, w kodzie BCD) ,

łańcuchy (bajtów, słów lub słów podwójnych),

pojedyncze bity w rejestrze lub w pamięci.

Liczby dwójkowe całkowite są przedstawiane w kodzie uzupełnieniowym U2 w jednym 8-bitowym bajcie, 16-bitowym słowie (word) lub 32-bitowym słowie podwójnym (doubleword). Zakres przedstawianych wartości wynosi odpowiednio:

bajt (- 128 ... + 127)

słowo (- 32 768 ... + 32 767)

słowo podwójne (- 2 147 483 648 ... + 2 147 483 647)


Liczby zmiennopozycyjne (floating-point numbers) są kodowane wg standardu IEEE 754 (oraz IEEE 854) jako liczby pojedynczej, podwójnej i rozszerzonej precyzji w formacie

krótkim (short real), 32-bitowym

31 30 22 0

s e f

1 8 23

długim (long real), 64-bitowym

31 30 22 0

s e f

1 11 52

chwilowym (temporary real), 80-bitowym

79 78 63 62 0

s e i f

1 15 1 63

Słowo dwójkowe w tych formatach, zależnie od wartości pola e (wykładnik) i pola f (mantysa), może być interpretowane jako

liczba znormalizowana (normalized)

em < e < eM

liczba nieznormalizowana (denormal)

e = em = 0...0 oraz f 0

zero e = em = 0...0 oraz f = 0

nieskończoność (INF) e = eM = 1...1 oraz f = 0

nieliczba (NaN) e = eM = 1...1 oraz f 0

f = 0 f 0

em < e < eM liczby znormalizowane

e = em = 0...0 0 liczby nieznormalizowane

e = eM = 1...1 INF NaN

Wartość liczby znormalizowanej krótkiej i długiej oblicza się wg wzoru:

(-1)s 2

e - b (1.f)

a w formacie chwilowym wg wzoru

(-1)s 2

e - b (i.f)


Wartość liczby nieznormalizowanej krótkiej i długiej oblicza się wg wzoru:

(-1)s 2

e - (b-1) (0.f)

a w formacie chwilowym wg wzoru

(-1)s 2

e - (b-1) (i.f)

Liczby nieznormalizowane w formacie chwilowym, dla których i=1 nazywają się pseudo-zdenormalizowanymi (pseudo-denormals).

Wartość b polaryzacji wykładnika (bias) wynosi w poszczególnych formatach 127, 1023, 16383.

Charakterystyka zakresu i dokładności liczb znormalizowanych:

Format | Lmin | | Lmax | Dokładność (cyfr dziesiętnych)

Krótki (32 b) 1,2 x 10-38

3,37 x 1038

6

Długi (64 b) 2,3 x 10-308

1,67 x 10308

15

Chwilowy (80 b) 3,4 x 10-4932

1,2 x 104932

18

Liczby w formacie krótkim i długim mogą być przechowywane w pamięci, natomiast format chwilowy stosowany jest tylko w jednostce zmiennoprzecinkowej (lub koprocesorze numerycznym) wykonującej działania na zawartości swoich 8 rejestrów 80-bitowych. Również liczby dziesiętne przy przekazaniu do koprocesora są zamieniane na format zmiennopozycyjny chwilowy. Przy zapisie wyników do pamięci następuje odpowiednia konwersja do formatu standardowego.

Liczby dziesiętne upakowane (packed decimal) są kodowane w łańcuchu 10 bajtów interpretowanym jako liczba całkowita ze znakiem.

79 78 71 63 15 7 3 0

s x c17 c16 c15 c4 c3 c2 c1 c0

s - bit znakowy liczby, x - bity nieznaczące, c1 .. c17 - kody BCD cyfr dziesiętnych.

Każdy bajt, poza bajtem najbardziej znaczącym, zawiera dwie cyfry dziesiętne w kodzie BCD. W bajcie najbardziej znaczącym zakodowany jest znak liczby wg reguły:

0000 0000 oznacza +,

1000 0000 oznacza -.

Zakres przedstawianych liczb dziesiętnych wynosi (-1018

+ 1) ... (1018

- 1) i pozwala na dokładną konwersję do formatu zmiennopozycyjnego chwilowego (dokładność 18 cyfr dziesiętnych).

Łańcuchy bajtów, słów lub słów podwójnych są argumentami rozkazów łańcuchowych. Adresacja elementów łańcucha jest zawsze domyślna:

dla segmentu DS przemieszczenie znajduje się w SI (lub ESI) i segmentu nie można zmienić,

dla segmentu ES przemieszczenie znajduje się w DI (lub EDI), przy czym segment można zmienić za pomocą przedrostka zmiany segmentu.

Kierunek przetwarzania łańcucha (adresy rosnące lub malejące) zależy od ustawienia bitu DF w słowie EFLAGS.

Kilka rozkazów działa na pojedynczych bitach (testowanie) i wskazuje numer bitu za pomocą dwóch parametrów:

adres bajta bazowego w pamięci lub identyfikator rejestru (adres w polu R/M),

przemieszczenie w stosunku do początkowego bitu bazy. Przemieszczenie to jest z zakresu - od - 32 768 do + 32 767 bitów dla parametru 16-bitowego - od - 2 147 483 648 do + 2 147 483 647 bitów dla parametru 32-bitowego.

Jeżeli bazą jest rejestr, to przemieszczenie jest ograniczone do wielkości rejestru.


System przerwań

Rozróżnia się przerwania zewnętrzne (interrupts) i przerwania wewnętrzne zwane wyjątkami (exceptions).

Przerwania zewnętrzne pochodzą od zdarzeń zewnętrznych sygnalizowanych na wejściu INTR lub NMI procesora. Przerwania zgłaszane na wejściu INTR mogą być maskowane; przyjmowane są tylko wtedy, gdy znacznik IF=1 (bit <9> słowa EFLAGS). Przerwania na wejściu NMI są niemaskowalne. Stan znacznika IF można zmieniać programowo rozkazami STI i CLI.

Wyjątki pochodzą od zdarzeń wewnętrznych wykrytych przez procesor. Wyjątki nie są maskowane bitem IF.

Każde przerwanie jest skojarzone z unikatowym 8-bitowym identyfikatorem, który jest indeksem tzw. tablicy wektorów (interrupt vector table) zawierającej adresy programów obsługi wszystkich dopuszczalnych przerwań. W trybie rzeczywistym tablica ta zajmuje 1024 początkowe bajty pamięci, gdyż każdy wektor jest dwusłowowy - zawiera selektor i przemieszczenie. Pod adresem 4k znajduje się przemieszczenie przesyłane do IP, pod adresem 4k+2 selektor przesyłany do CS. W trybie chronionym tablica ta nosi nazwę tablicy deskryptorów przerwań (interrupt descriptor table) i zawiera deskryptory, a jej maksymalna wielkość wynosi 2 KB.

Wywołanie programu obsługi k-go przerwania można spowodować rozkazem INT k (tzw. przerwanie programowe), często stosowanego w programach asemblerowych.

Po przyjęciu przerwania, procesor przesyła na stos (E)FLAGS, CS i (E)IP, zeruje IF, TF i NT a następnie przechodzi do właściwego programu obsługi.

Powrót do przerwanego programu następuje rozkazem IRET.

Priorytety przerwań zewnętrznych, ich wybiórcze maskowanie i przypisanie identyfikatorów następuje poza procesorem, w układach sterowników przerwań (np. stosowany jeszcze od czasu procesorów 8-bitowych, moduł 8259A).

Lista rozkazów

Rozkazy x86 są co najwyżej 2-argumentowe, przy czym tylko jeden argument może być umieszczony w pamięci. Wyjątkiem są rozkazy łańcuchowe, które stosując adresację pośrednią wskazują dwa adresy w pamięci. W niektórych rozkazach parametry operacji są umieszczane domyślnie w wybranych rejestrach (np. liczniki powtórzeń w (E)CX, adresy łańcuchów w (E)SI i (E)DI, adresy portów wejścia-wyjścia w DX).

W podanym zestawieniu pogrupowano rozkazy wg ich funkcji, opisując działanie w sposób sformalizowany tam gdzie nie prowadziło to do nadmiernie rozbudowanych wyrażeń.

Wiele rozkazów ma w języku asemblera mnemoniki synonimiczne, tzn. różne nazwy symboliczne generują taki sam kod operacyjny - wynika to z przyjętego trybu adresowania (np. POPF dla adresacji 16-bitowej i POPFD dla adresacji 32-bitowej) lub ma ułatwić programiście kojarzenie istoty wykonywanej operacji (np. różnorodne nazwy tych samych warunków w rozkazach skokowych).

Ze względu na możliwość występowania argumentów 16- i 32- bitowych, przyjęto w opisach ogólne oznaczenia rejestrów, miejsc w pamięci i stałych (np. Br, r/m, imm); wielkość argumentów zaznaczono jedynie tam gdzie nie wynika ona jednoznacznie z kontekstu (np. imm8, r16, m<63:0>). Rejestr segmentu (selektora) podano tylko w szczególnych przypadkach, tam gdzie to jest istotne (np. ES:DI w rozkazie MOVS).

Oznaczenia:

Ar, Br, Cr, Dr - odpowiedni rejestr danych:

AL, BL, CL, DL dla danych 8-bitowych,

AX, BX, CX, DX dla danych 16-bitowych

EAX, EBX, ECX, EDX dla danych 32-bitowych

IPr, SPr, SIr, DIr - odpowiedni rejestr adresowy:

IP,SP,SI,DI dla adresów 16-bitowych

EIP, ESP, ESI, EDI dla adresów 32-bitowych

r - dowolny rejestr adresowany w polu REG słowa rozkazowego

r/m - miejsce w pamięci lub rejestr adresowany w polu MOD-R/M słowa rozkazowego,


m - miejsce w pamięci adresowane w polu MOD-R/M słowa rozkazowego,

imm - argument bezpośredni zawarty w słowie rozkazowym,

fptr - pełny adres (full pointer) zapisany w postaci selektor (16-bitowy) : przemieszczenie (16- lub 32-bitowe),

iptr - wskaźnik przerwania (w tablicy przerwań),

lft - numer najbardziej znaczącego bitu argumentu (7,15 lub 31 - zależnie od formatu danych)

Przesłania

Komunikację rejestrów z pamięcią (typu load i store) i miedzy rejestrami zapewnia uniwersalny rozkaz MOVe. Ten sam mnemonik jest stosowany również do rozkazów uprzywilejowanych (wykonywanych tylko przez system operacyjny) mających argumenty w rejestrach systemowych.

Tab. 5.1. Rozkazy przesłań

Nazwa Składnia Wielkość argumentów

Działanie

Przesłanie danych MOV r,r/m MOV r/m,r MOV r/m,imm

8,16,32 8,16,32 8,16,32

r r/m

r/m r

r/m imm

Zamiana zawartości XCHG r/m,r XCHG r,r/m

8,16,32 8,16,32

r/m r

r r/m

Dodawanie i zamiana zawartości

XADD r/m,r

8,16,32

r r/m ; next

r/m r/m + r

Identyfikacja procesora

CPUID EAX {kod identyfikacji CPU}

Rozkaz XCHG umożliwia zamianę zawartości dwóch rejestrów lub rejestru i miejsca w pamięci. Rozkaz XADD, dodany w Pentium, po zamianie argumentów dodatkowo oblicza ich sumę.

Rozkaz identyfikacji typu procesora CPUID jest implementowany tylko w tych procesorach (poczynając od Pentium), w których jest aktywny znacznik ID w słowie EFLAGS.

Dostęp do stosu systemowego (rosnącego w kierunku adresów malejących!) umożliwiają rozkazy POP i PUSH; przy tym przesłanie na stos stałej 8-bitowej powoduje rozszerzenie tej stałej do formatu 16-bitowego z zachowaniem znaku.

Wszystkie główne rejestry procesora można zapamiętać na stosie jednym rozkazem PUSHA (rejestr SP/ESP zapamiętuje się w stanie sprzed wykonania rozkazu), podobnie można wszystkie te rejestry odtworzyć rozkazem POPA (SP/ESP nie jest wówczas odtwarzany).

Rozkazy ENTER i LEAVE przewidziane są do zastosowań w kompilatorach języków wysokiego poziomu. Rozkaz ENTER tworzy na stosie tzw. ramkę dla parametrów lokalnych procedury. Liczbę bajtów rezerwowanych w ramce pokazuje argument imm16. Przed utworzeniem ramki na stosie są umieszczane wskaźniki do ramek procedur, w których aktualna procedura jest zagnieżdżona, adres początku aktualnej ramki jest zapisywany w (E)BP. Poziom zagnieżdżenia pokazuje argument imm8 traktowany jako liczba 0..31. Rozkaz LEAVE, wykonywane przed wyjściem z procedury, usuwa ze stosu ramkę utworzoną poprzednio rozkazem ENTER, wykorzystując zawartość rejestru (E)BP pokazującą poprzedni szczyt stosu.


Tab. 5.2. Rozkazy komunikacji ze stosem


Działanie

Przesłanie na stos

PUSH r/m PUSH imm

16 32

8,16 32

SP SP-2; next M[SP] r/m

ESP ESP-4; next M[ESP] r/m

SP SP-2; next M[SP] imm

ESP ESP-4; next M[ESP] imm

Pobranie ze stosu

POP r/m 16 32

r/m M[SP]; next SP SP+2

r/m M[ESP]; next ESP ESP+4

Przesłanie rejestrów na stos

PUSHA 16

32

temp SP; next SP SP-2; next

M[SP] AX; next SP SP-2; next

M[SP] CX; next SP SP-2; next

M[SP] DX; next SP SP-2; next

M[SP] BX; next SP SP-2; next

M[SP] temp; next SP SP-2; next

M[SP] BP; next SP SP-2; next

M[SP] SI; next SP SP-2; next

M[SP] DI

temp ESP; next ESP ESP-4; next

M[ESP] EAX; next ESP ESP-4; next

M[ESP] ECX; next ESP ESP-4; next

M[ESP] EDX; next ESP ESP-4; next

M[ESP] EBX; next ESP ESP-4; next

M[ESP] temp; next ESP ESP-4; next

M[ESP] EBP; next ESP ESP-4; next

M[ESP] ESI; next ESP ESP-4; next

M[ESP] EDI

Pobranie rejestrów ze stosu

POPA 16

32

DI M[SP]; next SP SP+2; next

SI M[SP]; next SP SP+2; next

BP M[SP]; next SP SP+4; next

BX M[SP]; next SP SP+2; next

DX M[SP]; next SP SP+2; next

CX M[SP]; next SP SP+2; next

AX M[SP]; next SP SP+2

EDI M[ESP]; next ESP ESP+4; next

ESI M[ESP]; next ESP ESP+4; next

EBP M[ESP]; next ESP ESP+8; next

EBX M[ESP]; next ESP ESP+4; next

EDX M[ESP]; next ESP ESP+4; next

ECX M[ESP]; next ESP ESP+4; next

EAX M[ESP]; next ESP ESP+4

Utworzenie ramki dla procedury

ENTER imm16, imm8 16 {*} SP SP-2; next M[SP] BP; next

BP SP; next SP SP - imm16

Usunięcie ramki procedury

LEAVE 16 {*} SP BP; next BP M[SP]; next

SP SP + 2

{*} działanie rozkazu w przypadku imm8 = 0 i adresacji 16-bitowej.

Konwersja formatu

Możliwe są wszystkie sensowne (nie powodujące utraty informacji) zmiany formatu danych. Przy zamianie formatu krótkiego na długi (CBW/CWDE i CWD/CDQ) dane są traktowane jako liczby w kodzie uzupełnieniowym i bit znakowy jest powielany. Te dwa rozkazy dla każdego kodu


operacyjnego mają po dwa synonimiczne mnemoniki stosowane zależnie od aktualnej adresacji (16- lub 32-bitowej).

W rozkazach MOVZX i MOVSX rejestr docelowy r jest 16- lub 32-bitowy a argument r/m, odpowiednio, 8- lub 16-bitowy.

Rozkaz XLAT zmienia bajt zawarty w AL według tablicy kodowej umieszczonej pod adresem efektywnym wskazywanym przez BX (lub EBX). Zawartość AL jest traktowana jako 8-bitowa liczba bez znaku będąca indeksem tablicy kodowej; w wyniku operacji XLAT wskazany element tej tablicy jest przesyłany do AL.

Tab. 5.3. Rozkazy konwersji formatu


Działanie

Zamiana bajta na słowo Zamiana słowa na słowo podwójne

CBW CWDE

8

16

AX AL

EAX AX

Zamiana słowa na słowo podwójne Zamiana słowa podwójnego na poczwórne

CWD CDQ

16

32

DX^AX AX

EDX^EAX EAX

Przesłanie do dłuższego rejestru z uzupełnieniem zerami

MOVZX r, r/m 8,16,32 r 0^r/m

Przesłanie do dłuższego rejestru z powieleniem znaku

MOVSX r, r/m 8,16,32 r r/m

Tłumaczenie wg tablicy kodu

XLAT 8 AL M[EBX+AL]

Komunikacja z portami we-wy

Porty wejściowe i wyjściowe mogą być umieszczone w przestrzeni adresów pamięciowych lub w przestrzeni wejścia-wyjścia. W pierwszym przypadku porty mogą być argumentami rozkazów tak samo jak miejsca pamięci natomiast w drugim przypadku porty są dostępne tylko rozkazami IN, INS, OUT i OUTS.

W rozkazach IN i OUT komunikacja jest między portem (bajtowym, słowowym lub dwusłowowym) i akumulatorem (odpowiednio - AL, AX lub EAX). Przestrzeń adresów wejścia-wyjścia wynosi 64kB, przy czym adresy portów 16-bitowych muszą być parzyste, a adresy portów 32-bitowych podzielne przez 4. Adresy portów bezpośrednio podawane w rozkazie (imm) są ograniczone do zakresu 0 .. 255; pełny zakres adresów (0 .. 65535) jest osiągalny w adresacji pośredniej - poprzez rejestr DX.

Rozkazy łańcuchowe INS i OUTS mają obydwa adresy domyślne: port określony jest przez zawartość DX, a miejsce w pamięci przez SI (ESI) lub DI (EDI). Zależnie od ustawienia znacznika DF, po przesłaniu aktualizowane są adresy w SI i DI, dzięki czemu rozkazy te poprzedzone przedrostkiem REP wykonują odczytanie lub zapisanie łańcuchów bajtów, słów lub słów podwójnych.


Tab. 5.4. Rozkazy we-wy


Działanie

Odczytanie portu wejściowego

IN ar, imm IN ar, DX

8,16,32 ar port[imm]

ar port[DX]

Zapisanie do portu wyjściowego

OUT imm, ar OUT DX, ar

8,16,32 port[imm] ar

port[DX] ar

Odczytanie łańcucha z portu wejściowego

INS_ {B,W,D}

8,16,32

M[ES:DIr] port[DX]; next

(DF=0) => DIr inc DIr;

(DF=1) => DIr dec DIr;

Zapisanie łańcucha do portu wyjściowego

OUTS_ {B,W,D}

8,16,32

port[DX]<7:0> M[SIr]; next

(DF=0) => SIr inc SIr;

(DF=1) => SIr dec SIr;

Manipulacje znacznikami

Całe słowo stanu FLAGS lub EFLAGS można przenosić na stos (rozkaz PUSHF/PUSHFD) i ładować ze stosu (rozkaz POPF/POPFD). Każdy z tych rozkazów ma po dwa synonimiczne mnemoniki stosowane zależnie od trybu adresacji 16- lub 32-bitowej.

Rozkaz LAHF przenosi do rejestru AH osiem mniej znaczących bitów (E)FLAGS, natomiast rozkaz SAHF ładuje tę część słowa stanu z rejestru AH.

Niektóre znaczniki można zmieniać indywidualnie; dotyczy to znacznika przeniesienia (CF) i dwóch znaczników sterujących: IF (przyjmowanie bądź maskowanie przerwań zewnętrznych) i DF (kierunek przeglądania pamięci w operacjach łańcuchowych).

Tab. 5.5. Rozkazy manipulacji znacznikami


Działanie

Zapisanie znaczników na stos

PUSHF PUSHFD

16 32

SP SP - 2; next M[SP] FLAGS

ESP ESP - 4; next M[ESP] EFLAGS

Pobranie znaczników ze stosu

POPF POPFD

16 32

FLAGS M[SP]; next SP SP + 2

EFLAGS M[ESP]; next ESP ESP + 4

Przesłanie znaczników do AH

LAHF 8 AH EFLAGS <7:0>

Pobranie znaczników z AH

SAHF 8 EFLAGS <7:0> AH

Uzupełnienie CF CMC 1 CF not CF

Zerowanie CF CLC 1 CF 0

Zerowanie DF CLD 1 DF 0

Zerowanie IF CLI 1 IF 0

Ustawienie CF STC 1 CF 1

Ustawienie DF STD 1 DF 1

Ustawienie IF STI 1 IF 1

Działania na adresach

Istnieje możliwość określenia efektywnego adresu logicznego wskazanej zmiennej i umieszczenie go we wskazanym rejestrze. W zależności od aktualnej adresacji jest to adres o przemieszczeniu 16- lub 32-bitowym. Rozkaz LEA ładuje do rejestru tylko przemieszczenie, pozostałe rozkazy przesyłają przemieszczenie do wskazanego rejestru ogólnego a selektor do odpowiedniego rejestru segmentowego.


Tab. 5.6. Rozkazy działające na adresach


Działanie

Ładowanie przemieszczenia do rejestru

LEA r,m 16 32

r fptr<15:0> {offset}

r fptr<31:0> {offset}

Ładowanie pełnego adresu do DS i r

LDS r,m 32 48

r fptr<15:0>; DS fptr<31:16>

r fptr<31:0>; DS fptr<47:32>

Ładowanie pełnego adresu do ES i r

LES r,m 32 48

r fptr<15:0>; ES fptr<31:16>

r fptr<31:0>; ES fptr<47:32>

Ładowanie pełnego adresu do FS i r

LFS r,m 32 48

r fptr<15:0>; FS fptr<31:16>

r fptr<31:0>; FS fptr<47:32>

Ładowanie pełnego adresu do GS i r

LGS r,m 32 48

r fptr<15:0>; GS fptr<31:16>

r fptr<31:0>; GS fptr<47:32>

Ładowanie pełnego adresu do SS i r

LSS r,m 32 48

r fptr<15:0>; SS fptr<31:16>

r fptr<31:0>; SS fptr<47:32>

Działania arytmetyczne na liczbach całkowitych

Dostępne są cztery podstawowe działania oraz zwiększanie (INC) i zmniejszanie (DEC) o 1(tab.5.7). Oprócz zwykłego dodawania (ADD) i odejmowania (SUB) są też wersje tych rozkazów umożliwiające działanie na formatach zwielokrotnionych (ADC i SBB) dzięki uwzględnianiu przeniesień (pożyczek) wygenerowanych w poprzednich rozkazach. Mnożenie i dzielenie ma wersje bezznakowe (MUL i DIV) oraz wersje działające na argumentach ze znakiem, w kodzie uzupełnieniowym (IMUL, IDIV). Mnożna i dzielna musi być w akumulatorze (z ewentualnym rozszerzeniem na rejestr Dr), a po wykonaniu działań jest tam umieszczany wynik. Po dzieleniu pamiętany jest zarówno iloraz jak i reszta z dzielenia. Gdy wynik nie mieści się w akumulatorze, lub dzielnik jest zerem zgłaszany jest wyjątek.

Korekcja dziesiętna

Podstawowa lista rozkazów umożliwia pisanie programów przetwarzających liczby dziesiętne bez znaku zapisane w kodzie BCD. Jeżeli cyfry dziesiętne są kodowane w kolejnych tetradach (po dwie w jednym bajcie), to taki format jest określany jako upakowany, jeżeli cyfry są kodowane po jednej w bajcie (np. tak, jak znaki cyfr w kodzie ASCII) to taki format nazywany jest nieupakowanym.

Dla formatu upakowanego są dwa rozkazy korekcji: po dodawaniu (DAA) i po odejmowaniu (DAS). Działają one na zawartości rejestru AL, przy założeniu że został tam umieszczony wynik dodawania (odejmowania) dwójkowego 2-cyfrowych liczb BCD. W takim przypadku aby suma dwójkowa reprezentowała sumę dziesiętną konieczna jest korekcja wyniku przez dodanie (odjęcie 6) do tetrad, których wartość dwójkowa jest większa od 9.

Podobnie działają rozkazy AAA i AAS z tym, ze korekcja dotyczy tylko mniej znaczącej tetrady a ewentualne przeniesienie dodawane jest do następnego bajta w rejestrze AH; bardziej znacząca tetrada w AL jest zerowana.

Rozkaz korekcji po mnożeniu (AAM) wydziela z iloczynu 1-cyfrowych liczb BCD zapisanego w AL liczbę dziesiątek i umieszcza ją w AH oraz liczbę jedności i umieszcza ją w AL.

Korekcja przed dzieleniem (AAD) przygotowuje w AL postać dwójkową 2-cyfrowej dziesiętnej liczby nieupakowanej zapisanej w AL (bardziej znacząca cyfra BCD) i AH (mniej znacząca cyfra BCD).

Porównania

Rozkaz CMP porównujący dwa argumenty przez ich odjęcie jest typowym rozkazem poprzedzającym operacje warunkowe (skoki i ustawienia bajta - tab.5.16). Wynik odejmowania nie jest nigdzie zapamiętywany a jedynie powoduje ustawienie znaczników w słowie EFLAGS.

Rozkazy porównania i zamiany są 3-argumentowe (pierwszy argument jest umieszczony domyślnie w akumulatorze lub przedłużonym akumulatorze EDX^EAX); wykrycie równości dwóch argumentów powoduje przesłanie trzeciego argumentu na miejsce drugiego z nich. Rozkaz CMPXCHG8B, dodany dopiero w procesorze Pentium, jest jedynym rozkazem działającym explicite na argumentach 64-bitowych.

Rozkaz BOUND bada, czy indeks tablicy mieści się w zadanych granicach. Indeks musi być umieszczony w rejestrze r (16- lub 32-bitowym), natomiast dolna i górna granica muszą być umieszczone w pamięci m jako kolejne dwa słowa lub słowa podwójne. Przekroczenie granic powoduje generowanie wyjątku nr 5.


Tab.5.7. Rozkazy działań arytmetycznych


Działanie

Dodawanie ADD Ar, imm ADD r/m,imm ADD r/m,r ADD r,r/m

8,16,32 Ar Ar + imm

r/m r/m + imm

r/m r/m + r

r r + r/m

Dodawanie z przeniesieniem

ADC Ar, imm ADC r/m,imm ADC r/m,r ADC r,r/m

8,16,32 Ar Ar + imm + CF

r/m r/m + imm + CF

r/m r/m + r + CF

r r + r/m + CF

Odejmowanie SUB Ar, imm SUB r/m,imm SUB r/m,r SUB r,r/m

8,16,32 Ar Ar - imm

r/m r/m - imm

r/m r/m - r

r r - r/m

Odejmowanie z pożyczką

SBB Ar, imm SBB r/m,imm SBB r/m,r SBB r,r/m

8,16,32 Ar Ar - imm - CF

r/m r/m - imm - CF

r/m r/m - r - CF

r r - r/m - CF

Mnożenie liczb bez znaku

MUL r/m 8 16 32

AX AL * r/m {us}

DXÂX AX * r/m {us}

EDXÊAX EAX * r/m {us}

Mnożenie IMUL r/m IMUL r,r/m IMUL r,imm IMUL r,r/m,imm

8 16 32

8,16,32 8,16,32 8,16,32

AX AL * r/m

DXÂX AX * r/m

EDXÊAX EAX * r/m

r r * r/m

r r * imm

r r/m * imm

Dzielenie liczb bez znaku

DIV r/m 8 16

32

AL AX / r/m {us}; AH AX mod r/m

AX DXÂX / r/m {us};

DX DXÂX mod r/m

EAX EDXÊAX / r/m {us};

EDX EDXÊAX mod r/m

Dzielenie IDIV r/m 8 16

32

AL AX / r/m ; AH AX mod r/m

AX DXÂX / r/m ;

DX DXÂX mod r/m

EAX EDXÊAX / r/m ;

EDX EDXÊAX mod r/m

Zwiększenie o 1 INC r/m 8,16,32 r/m r/m + 1

Zmniejszenie o 1 DEC r/m 8,16,32 r/m r/m - 1

Działania logiczne

Rozkazy logiczne wykonują działania boolowskie sumy (OR), iloczynu (AND), różnicy symetrycznej (XOR) i uzupełnienia (NOT) na odpowiadających sobie pozycjach argumentów traktowanych jako łańcuchy bitowe. Rozkaz TEST oblicza iloczyn logiczny w celu ustawienia znaczników ZF, SF i PF (CF i OF są zerowane) ale nie zapisuje wyniku i nie zmienia argumentów.


Tab.5.8. Rozkazy porównań


Działanie

Porównanie CMP r/m, r CMP r, r/m CMP r/m, imm

8,16,32 8,16,32 8,16,32

r/m - r; next {EFLAGS} r - r/m; next {EFLAGS} r/m - imm; next {EFLAGS}

Porównanie z akumulatorem i zamiana

CMPXCHG r/m, m 8,16,32 (Ar = r/m) => Ar r/m; next

r/m m; ZF 1;

(Ar r/m) => Ar r/m; ZF 0;

Porównanie i zamiana słów poczwórnych

CMPXCHG8B r/m 64 (EDXÊAX = r/m<64:0>) =>

(EDXÊAX r/m<64:0>; next

r/m<64:0> ECXÊBX; ZF 1);

(EDXÊAX r/m<64:0>) =>

(EDXÊAX r/m<64:0>; ZF 0)

Sprawdzenie ograniczeń indeksu

BOUND r,m 16

32

(r < m<15:0>) or (r > m<32:16>) => wyjątek #5 (r < m<31:0>) or (r > m<63:32>) => wyjątek #5

Przesunięcia

Przesunięcia mogą dotyczyć rejestru lub miejsca w pamięci. Liczba przesunięć (od 0 do 31) jest podawana bezpośrednio (stała imm) lub pośrednio - jako zawartość rejestru CL (tab.5.11).

Są przesunięcia cykliczne, logiczne i arytmetyczne (z zachowaniem bitu znakowego). Przesunięcia cykliczne mogą dotyczyć argumentu wydłużonego o bit znacznika CF (RCL i RCR); dzięki temu można łatwo realizować przesunięcia argumentów wielokrotnych.

Dla przesunięcia logicznego w lewo (SHL) jest synonimiczny mnemonik SAL („przesunięcie arytmetyczne w lewo”).

Tzw. przesunięcia długie (SHLD i SHRD) polegają na przesunięciu logicznym wskazanego argumentu z jednoczesnym zapełnieniem zwolnionych miejsc zawartością wskazanego rejestru, przy czym zawartość tego rejestru po wykonaniu rozkazu nie ulega zmianie.

Specyficzny rodzaj przesunięcia realizuje rozkaz BSWAP; jego wykonanie polega na przestawieniu bajtów w słowie (lub słowie podwójnym) z zachowaniem uporządkowania bitów w bajtach. Rozkaz ten dotyczy tylko rejestrów.

Tab.5.9. Rozkazy korekcji dziesiętnej


Działanie

Korekcja 2 cyfr upakowanych BCD po dodawaniu

DAA 8 (AF or AL<3:0> grt 9) =>

AL<7:0> AL<3:0> + 6; next (CF or AL<7:4> grt 9) =>

CFÂL<7:4> AL<7:4> + 6

Korekcja 2 cyfr upakowanych BCD po odejmowaniu

DAS 8 (AF or AL<3:0> grt 9) =>

AL<7:0> AL<3:0> - 6; next (CF or AL<7:4> grt 9) =>

CFÂL<7:4> AL<7:4> - 6

Korekcja cyfry BCD po dodawaniu

AAA 16 (AF or AL<3:0> grt 9) =>

AL<3:0> AL<3:0> + 6; next

AL<7:4> 0; AH AH + 1

Korekcja cyfry BCD po odejmowaniu

AAS 16 (AF or AL<3:0> grt 9) =>

AL<3:0> AL<3:0> - 6; next

AL<7:4> 0; AH AH - 1

Korekcja BCD po mnożeniu

AAM 16 AH AL / 10; next AL AL mod 10

Korekcja BCD przed dzieleniem

AAD 16 AL (AH * 10) + AL; next AH 0


Tab.5.10. Rozkazy działań logicznych


Działanie

Iloczyn logiczny AND r,r/m AND r/m,r AND r/m,imm

8,16,32 r r and r/m

r/m r/m and r

r r/m and imm

Suma logiczna OR r,r/m OR r/m,r OR r/m,imm

8,16,32 r r or r/m

r/m r/m or r

r r/m or imm

Różnica symetryczna XOR r,r/m XOR r/m,r XOR r/m,imm

8,16,32 r r xor r/m

r/m r/m xor r

r r/m xor imm

Uzupełnienie logiczne

NOT r/m 8,16,32 r/m not r/m

Testowanie TEST r,r/m TEST r,imm TEST r/m,r

8,16,32 r and r/m; {EFLAGS} r and imm; {EFLAGS} r/m and r; {EFLAGS}

Tab.5.11. Rozkazy przesunięć


Działanie

Przesunięcie cykliczne w lewo

ROL r/m,imm ROL r/m,CL

8,16,32 r/m imm rol r/m; next CF r/m<0>

r/m CL rol r/m; next CF r/m<0>

Przesuniecie cykliczne w prawo

ROR r/m,imm ROR r/m,CL

8,16,32 r/m imm ror r/m; next CF r/m<lft>

r/m CL ror r/m; next CF r/m<lft>

Przesunięcie przez CF cykliczne w lewo

RCL r/m,imm RCL r/m,CL

8,16,32 CF^r/m imm rol (CF^r/m);

CF^r/m CL rol (CF^r/m);

Przesuniecie przez CF cykliczne w prawo

RCR r/m,imm RCR r/m,CL

8,16,32 CF^r/m imm ror (CF^r/m);

CF^r/m CL ror (CF^r/m);

Przesunięcie w lewo SHL r/m,imm SAL r/m,imm SHL r/m,CL SAL r/m,CL

8,16,32 CF^r/m imm shl (CF^r/m);

CF^r/m CL shl (CF^r/m);

Przesuniecie w prawo SHR r/m,imm SHR r/m,CL

8,16,32 r/m^CF imm shr (r/m^CF);

r/m^CF CL shr (r/m^CF);

Przesuniecie arytmetyczne w prawo

SAR r/m,imm SAR r/m,CL

8,16,32 r/m^CF imm ashr (r/m^CF);

r/m^CF CL ashr (r/m^CF);

Przesuniecie długie w lewo

SHLD r/m,r,imm SHLD r/m,r,CL

8,16,32 CF^r/m^ t imm shl (CF^r/m^r);

CF^r/m^ t CL shl (CF^r/m^r);

Przesuniecie długie w prawo

SHRD r/m,r,imm SHRD r/m,r,CL

8,16,32 t^r/m^ CF imm shr (r^r/m^CF);

t^r/m^ CF imm shr (r^r/m^CF);

Przestawienie bajtów BSWAP r 16, 32

r<15:8> r<7:0>;

r<31:24> r<7:0>; r<23:16> r<15:8>;

Działania na pojedynczych bitach

Rozkazy tej grupy (tab.5.12) badają i ewentualnie zmieniają wskazany bit (rozkazy testowania) albo przeglądają łańcuchy bitów w pamięci lub w rejestrach w poszukiwaniu 0 lub 1 (rozkazy przeszukiwania).

W rozkazach testowania położenie bitu określone jest w stosunku do początku bajta wskazanego przez pierwszy argument; odległość od tego początku podaje drugi argument (rejestr lub stała) traktowany jako liczba ze znakiem. Przy adresacji 16-bitowej dostępny jest łańcuch w zakresie od -2

15

do +(215

- 1) bitów w stosunku do bazy. Dla adresacji 32-bitowej jest to zakres od -231

do +(231

- 1) bitów. Przy badaniu rejestrów, odległość jest liczona modulo długość rejestru.

Rozkazy przeszukiwania (BSF, BSR) mogą przeglądać tylko słowa lub słowa podwójne.


Tab.5.12. Rozkazy działające na bitach


Działanie

Testowanie bitu BT r/m,r BT r/m,imm

16,32 CF r/m <r>

CF r/m <imm>

Testowanie bitu z ustawieniem

BTS r/m,r BTS r/m,imm

16,32 CF r/m <r>; next r/m <r> 1

CF r/m <imm>; next r/m <r> 1

Testowanie bitu z zerowaniem

BTR r/m,r BTR r/m,imm

16,32 CF r/m <r>; next r/m <r> 0

CF r/m <imm>; next r/m <r> 0

Testowanie bitu z uzupełnieniem

BTC r/m,r BTC r/m,imm

16,32 CF r/m <r>; next r/m <r> not r/m <r>

CF r/m <imm>; next r/m <r> not r/m <r>

Przeszukiwanie bitów w przód

BSF r, r/m 16,32 r nr pierwszego (od <0>) bitu w r/m zawierającego 1

Przeszukiwanie bitów wstecz

BSR r, r/m 16,32 r nr pierwszego (od <15> lub <31>) bitu w r/m zawierającego 1

Działania na łańcuchach

Rozkazy tej grupy (tab.5.13) działają na pojedynczych bajtach, słowach lub słowach podwójnych lecz kiedy są użyte z przedrostkiem powtórzeń (REP_) wówczas mogą przetwarzać całe łańcuchy elementów. Adresacja argumentów jest domyślna: argument źródłowy wskazuje rejestr SIr, argument docelowy - rejestr DIr. Domyślny segment źródłowy (DS) można zmienić przedrostkiem zmiany segmentu, natomiast nie można zmienić segmentu docelowego (ES).

Kierunek przetwarzania łańcucha jest wskazywany przez bit DF (bit <10> w EFLAGS). Aktualizacja adresów po wykonaniu działania następuje automatycznie o 1, 2 lub 4 - zależnie od formatu argumentu (bajt, słowo, słowo podwójne).

Do rozkazów łańcuchowych stosuje się przedrostki REP, REPZ/REPE, REPNZ/REPNE powodujące wielokrotne wykonywanie następującego po nich rozkazu. Licznik powtórzeń jest pamiętany w CXr i po każdym wykonaniu rozkazu zmniejszany o 1.

REP powoduje wykonywanie rozkazu aż do wyzerowania licznika.

REPZ (synonimiczna nazwa REPE) powoduje wykonywanie rozkazu dopóki ZF=1 i nie wyzeruje się licznik.

REPNZ (synonimiczna nazwa REPNE) powoduje wykonywanie rozkazu dopóki ZF=0 i nie wyzeruje się licznik.

Tab.5.13. Rozkazy łańcuchowe


Działanie

Przesłanie łańcucha

MOVS_ {B,W,D} 8,16,32 M[ES:DIr] M[SIr]; next

(DF=0) => DIr inc DIr; SIr inc SIr;

(DF=1) => DIr dec DIr; SIr dec SIr

Porównanie łańcucha

CMPS_ {B,W,D} 8,16,32 M[SIr] - M[ES:DIr]; next {EFLAGS}; next



Przeszukiwanie łańcucha

SCAS_ {B,W,D} 8,16,32 M[SIr] - Ar; next {EFLAGS}; next



Ładowanie elementów łańcucha

LODS_ {B,W,D} 8,16,32 Ar M[SIr] ; next



Zapamiętywanie elementów łańcucha

STOS_ {B,W,D} 8,16,32 M[DIr] Ar ; next



Rozkazy sterujące przebiegiem programu

Zmiana sekwencji wykonywanych rozkazów jest możliwa przez użycie rozkazów skokowych, wywołań procedur, tzw. przerwań programowych i rozkazów powrotu.


Skoki bezwarunkowe i wywołania procedur

Skoki bezwarunkowe (tab.5.14) i wywołania procedur (tab.5.15) mają po cztery formaty - zależnie od sposobu i zakresu wskazywanego adresu docelowego. Jeżeli adres jest w obrębie tego samego segmentu wystarczy podać tylko przemieszczenie, jeżeli adres jest w innym segmencie trzeba podać jeszcze selektor. W każdym przypadku dopuszczalna jest adresacja bezpośrednia (przemieszczenie lub pełny adres jest argumentem rozkazu) lub adresacja pośrednia (w rozkazie wskazuje się tylko miejsce, gdzie znajduje się przemieszczenie lub pełny adres). W adresacji pośredniej można stosować rejestry.

Wywołania procedur, przed przejściem do wskazanego adresu, przesyłają adres powrotu (czyli adres rozkazu następującego w programie za rozkazem CALL) na stos.

Specyficznym sposobem wywołania procedury jest rozkaz „przerwania programowego” INT k, który symuluje zgłoszenie przerwania o numerze k; przejście do programu obsługi następuje poprzez tablicę wektorów przerwań, tak jak przy przerwaniach zewnętrznych i wyjątkach. Dwa spośród tych rozkazów mają swoje specyficzne kody: rozkaz INT 3 jest jednobajtowy i przewidziano go do ustawiania pułapek przy uruchamianiu programów, rozkaz INTO (przerwanie gdy był nadmiar), również jednobajtowy, działa warunkowo - jeżeli znacznik nadmiaru jest ustawiony (OF=1), to następuje przejście do procedury obsługi przerwania nr 4.

Tab.5.14. Skoki bezwarunkowe


Działanie

Wewnątrzsegmentowy bezpośredni

JMP d 8,16,32 IPr IPr + d

Wewnątrzsegmentowy pośredni

JMP r/m 8,16,32 IPr M[r/m]

Międzysegmentowy bezpośredni

JMP fptr 32,48 IPr fptr<31:0> {offset};

CS fptr<47:32> {selector}

Międzysegmentowy pośredni

JMP r/m 32,48 IPr M[r/m] {offset};

CS M[r/m+4] {selector}

Tab.5.15. Wywołanie procedury


Działanie

Wewnątrzsegmentowe bezpośredni

CALL d 8,16,32 SPr SPr - 4; next M[SPr] IPr; next

IPr IPr + d

Wewnątrzsegmentowe pośredni

CALL r/m 8,16,32 SPr SPr - 4; next M[SPr] IPr; next

IPr M[r/m]

Międzysegmentowe bezpośredni

CALL fptr 32,48 SPr SPr - 4; next M[SPr] IPr; next

IPr fptr<31:0> {offset};

CS fptr<47:32> {selector}

Międzysegmentowe pośredni

CALL r/m 32,48 SPr SPr - 4; next M[SPr] IPr; next

IPr M[r/m] {offset};

CS M[r/m+4] {selector}

Przerwanie programowe

INT imm 8 SPr SPr - 4; next M[SPr] CS; next

SPr SPr - 4; next M[SPr] EIP; next

IPr iptr<31:0> {offset};

CS iptr<47:32> {selector}

Skoki warunkowe

Skoki warunkowe (tab.5.16) są skokami wewnątrzsegmentowymi względnymi, co znaczy, że argument rozkazu podaje odległość skoku traktowaną jako liczba ze znakiem dodawana do adresu pamiętanego w IP (EIP), czyli do adresu następnego rozkazu.

Mają one ogólną postać Jcc, gdzie cc jest mnemonicznym skrótem warunku wykonania skoku. Warunki są określone na podstawie aktualnego stanu znaczników w słowie FLAGS; jeżeli warunek (cnd) jest spełniony (ma wartość logiczną 1), to wykonywany jest skok względny

cnd => IPr IPr + d

w przeciwnym przypadku pobierany jest następny rozkaz programu (wówczas skok jest nieefektywny).


Mnogość mnemoników dopuszczalnych w asemblerze pochodzi z różnej interpretacji argumentów, które były porównywane (CMP) przed rozkazem skoku - mogą one być traktowane jako liczby ze znakiem lub jako liczby dodatnie bez znaku.

Wśród rozkazów warunkowych są rozkazy stosowane do organizowania pętli programowych (tab.5.17). W tych rozkazach rejestr CX (ECX) pełni rolę licznika powtórzeń aktualizowanego po każdym wykonaniu rozkazu. Dodatkowym warunkiem może być stan znacznika ZF (LOPE, LOOPNE).

Rozkazy powrotu

Rozkazy RET umieszczane na końcu procedury (tab.5.18) zapewniają powrót do programu wywołującego, realizowany przez zdjęcie ze stosu adresu powrotnego (w postaci przemieszczenia - dla skoków wewnatrzsegmentowych lub w postaci pełnego adresu - dla skoków międzysegmentowych). Podobnie działają rozkazy powrotu z obsługi przerwań (IRET); w tym przypadku oprócz odtworzenia adresu jest też odtwarzane słowo znaczników (E)FLAGS.

Tab.5.16. Rozkazy warunkowe: skoki i ustawianie bajta

Nazwa warunku wykonania skoku lub ustawienia bajtu

(Jcc i SETcc)

Mnemonik rozkazu ustawiania bajtu

Mnemonik skoku

warunkowego

Warunek logiczny (cnd)

zero równe

SETZ SETE

JZ JE

ZF

nie zero nie równe

SETNZ SETNE

JNZ JNE

not ZF

przeniesienie poniżej nie powyżej lub równe

SETC SETB SETNAE

JC JB JNAE

CF

nie ma przeniesienia nie poniżej powyżej lub równe

SETNC SETNB SETAE

JNC JNB JAE

not CF

minus SETS JS SF

plus SETNS JNS not SF

nadmiar SETO JO OF

nie ma nadmiaru SETNO JNO not OF

jest parzystość parzyste

SETP SETPE

JP JPE

PF

nie ma parzystości nieparzyste

SETNP SETPO

JNP JPO

not PF

poniżej lub równe nie powyżej

SETBE SETNA

JBE JNA

CF or ZF

mniejsze nie większe lub równe

SETL SETNGE

JL JNGE

SF OF

mniejsze lub równe nie większe

SETLE SETNG

JLE JNG

SF OF or ZF

nie mniejsze większe lub równe

SETNL SETGE

JNL JGE

SF = OF

nie mniejsze lub równe większe

SETNLE SETG

JNLE JG

(not CF) and (not ZF)

rejestr CX wyzerowany - JCXZ CX = 0

rejestr ECX wyzerowany - JECXZ ECX = 0

Warunkowe ustawianie bajta

Z tych samych warunków, co skoki warunkowe, korzystają rozkazy warunkowego ustawiania bajta (tab.5.16). Rozkazy te mają ogólna postać

SETcc r/m

a ich wykonanie polega na wpisaniu do wskazanego bajta 1 lub 0, zależnie od spełnienia warunku podanego w rozkazie:

cnd => r/m 1; not cnd => r/m 0.


Tab.5.17. Rozkazy organizujące pętle w programie.


Działanie

Pętla z licznikiem LOOP d 8 Cr Cr - 1; next

(Cr 0) => IPr IPr + d

Pętla dopóki zero LOOPE d LOOPZ d

8 Cr Cr - 1; next

(Cr 0 and ZF) => IPr IPr + d

Pętla dopóki nie zero LOOPNE d LOOPNZ d

8 Cr Cr - 1; next

(Cr 0 and not ZF) => IPr IPr + d

Tab.5.18. Rozkazy powrotu


Działanie

Powrót z procedury, wewnątrzsegmentowy

RET IPr M[SPr]; next SPr SPr + 4

Powrót z procedury, międzysegmentowy

RET IPr M[SPr]; next SPr SPr + 4; next

CS M[SPr]; next SPr SPr + 4

Powrót z procedury, wewnątrzsegmentowy z czyszczeniem stosu

RET imm 16 IPr M[SPr]; next SPr SPr + 4 + imm

Powrót z procedury, międzysegmentowy z czyszczeniem stosu

RET imm 16 IPr M[SPr]; next SPr SPr + 4; next

CS M[SPr]; next SPr SPr + 4 + imm

Powrót z przerwania IRET IRETD

IP M[SP]; next SP SP + 2; next

CS M[SP]; next SP SP + 2; next

FLAGS M[SP]; next SP SP + 2

EIP M[ESP]; next ESP ESP + 4; next

CS M[ESP]; next ESP ESP + 4; next

EFLAGS M[ESP]; next ESP ESP + 4

Operacja pusta

Jednobajtowy rozkaz NOP (no operation) o kodzie operacyjnym 90h, nie powoduje żadnej akcji procesora nie zmienia znaczników i nie generuje żadnych wyjątków. Bywa użyteczny do realizacji opóźnień w programach, do wyrównywania adresu następnego rozkazu lub do chwilowego usunięcia rozkazu np. przy uruchamianiu krokowym.

Rozkazy systemowe

Istnieje grupa rozkazów, które zmieniają zawartość rejestrów systemowych (np. rejestry tablic deskryptorów, rejestr sterujący CR0) lub zawartość pamięci buforowej (np. rozkaz INVD opróżnia pamięć cache) i dlatego jedynie system operacyjny powinien z nich korzystać. Do grupy tej należy też rozkaz HALT powodujący zatrzymanie pracy procesora aż do przyjęcia przerwania zewnętrznego (INTR lub NMI) lub sygnału RESET.

Rozkazy tej grupy są w większości uprzywilejowane, tzn. mogą być wykonywane tylko na najwyższym, zerowym poziomie ochrony (określonym w deskryptorze segmentu). Repertuar rozkazów systemowych zmienia się zależności od modelu procesora i zmieniającej się organizacji wewnętrznej.

Działania na liczbach zmiennoprzecinkowych (FPU)

Działania na liczbach zmiennoprzecinkowych są wykonywane w jednostce zmiennoprzecinkowej (FPU) lub, w starszych modelach, w koprocesorze numerycznym. Argumenty działań arytmetycznych muszą się znajdować w 80-bitowych rejestrach ST0 .. ST7 tworzących stos obliczeniowy FPU.

Fizycznie, stos jest zrealizowany w 8 rejestrach R0 .. R7. Każdy rejestr jest skojarzony z 2 bitowym polem stanu rejestru (tag field) podającym interpretację zawartości rejestru:


00 - poprawna liczba zmp. (valid)

01 - zero,

10 - wartość specjalna lub nieskończoność,

11 - rejestr pusty.

Aktualny wierzchołek stosu jest określony przez 3-bitowy wskaźnik stosu ST zawarty w rejestrze stanu FPU (status register). Programowo nie ma możliwości bezpośredniego adresowania rejestrów Ri; adresuje się zawsze względem aktualnego wierzchołka stosu. Inkrementacja i dekrementacja ST - co odpowiada odpowiednio obniżaniu i zwiększaniu stosu - następuje modulo 8. W związku z tym, przyjęto oznaczenia:

ST0 - rejestr będący aktualnym wierzchołkiem stosu, ST0 := R[ST],

STi - rejestr na pozycji i-tej poniżej wierzchołka stosu, STi := R[ST - i {mod 8}]

rst - dowolny rejestr stosu, ST0 .. ST7.

Uwaga: w języku asemblera rejestry stosu obliczeniowego są oznaczane ST(i), przy czym wierzchołek stosu jest oznaczany również jako ST (np. rozkaz mnożenia „FMUL ST, ST(0)” powoduje podniesienie do kwadratu liczby będącej na wierzchołku stosu).

Przesłanie na stos, zapisywane

ST0 X

jest wykonywane jako sekwencja czynności:

ST ST - 1 {mod 8}; next R[ST] X.

Przy przesyłaniu na stos i-go rejestru stosu (ST0 STi) brany jest numer i sprzed aktualizacji ST:

temp STi ; next ST ST - 1 {mod 8}; next R[ST] temp

Szesnastobitowy rejestr stanu FPU, oprócz wskaźnika stosu ST, zawiera znaczniki błędów i 4 bity rodzaju wyniku: C3 .. C0 (condition code bits) ustawiane przez rozkazy badania wyniku.

Działania zmiennoprzecinkowe są wykonywane na liczbach w 80-bitowym formacie chwilowym (rozszerzonym). W związku z tym wszelkie rozkazy, które wskazują argument przechowywany w pamięci jako liczba całkowita, zmiennoprzecinkowa krótka lub długa albo jako liczba dziesiętna powodują najpierw konwersję tego argumentu do standardowej postaci 80-bitowej a następnie wykonanie właściwej operacji.

W tablicach 5.19 - 5.26 zestawiono rozkazy jednostki FPU grupując je według funkcji.

Rozkazy przesłań (tab.5.19) służą do komunikacji rejestrów FPU z pamięcią; przy przesłaniach następują automatycznie stosowne zmiany formatu.

Badanie argumentów zmiennoprzecinkowych (tablice 5.20 - 5.22) ustawiają znaczniki C0, C2 i C3 w rejestrze stanu FPU.

Niektóre, często używane stałe (np. 0, 1, , ln 2, log102) można wprowadzić na stos obliczeniowy z pełną dokładnością, jaką zapewnia format rozszerzony, za pomocą rozkazów ładowania stałych (tab. 5.23).

Wśród rozkazów arytmetycznych (tab.5.24) oprócz czterech podstawowych działań (+, -, * i /) jest obliczanie pierwiastka kwadratowego, wartości bezwzględnej, liczby odwrotnej, zaokrąglanie do liczby całkowitej oraz wydzielanie z liczby jej wykładnika i mantysy.

Grupa obliczania funkcji przestępnych (tab.5.25) zawiera funkcje trygonometryczne sinus, cosinus, tangens i arcus tangens a także funkcję f = 2

x - 1 umożliwiającą obliczanie wartości funkcji

wykładniczej dla dowolnej podstawy oraz dwie funkcje f = y*log2x i f = y*log2(x+1), dzięki którym możliwe jest znajdowanie logarytmów o dowolnej podstawie.


Tab.5.19. Rozkazy przesłań FPU


Działanie

Ładowanie liczby zmiennoprzecinkowej

FLD STi FLD m32 FLD m64 FLD m80

80 32 64 80

ST0 STi

ST0 m<31:0> {flp80 flp32}

ST0 m<63:0> {flp80 flp64}

ST0 m<79:0> {flp80 flp80}

Ładowanie liczby całkowitej

FILD m16 FILD m32 FILD m64

16 32 64

ST0 m<15:0> {flp80 int16}

ST0 m<31:0> {flp80 int32}

ST0 m<63:0> {flp80 int64}

Ładowanie liczby dziesiętnej

FBLD m80 80 ST0 m<79:0> {flp80 pdec80}

Zmiennoprzecinkowe zapamiętanie ST0

FSD STi FSD m32 FSD m64

80 32 64

STi ST0

m<31:0> ST0 {flp32 flp80}

m<63:0> ST0 {flp64 flp80}

Zmiennoprzecinkowe zapamiętanie ST0 i zdjęcie ze stosu

FSTP STi FSTP m32 FSTP m64 FSTP m80

80 32 64 80

STi ST0 ; next ST ST+1

m<31:0> ST0 {flp32 flp80}; next ST ST+1



Całkowitoliczbowe zapamiętanie ST0

FIST m16 FIST m32

16 32

m<15:0> ST0 {int16 flp80}

m<31:0> ST0 {int32 flp80}

Całkowitoliczbowe zapamiętanie ST0 i zdjęcie ze stosu

FISTP m16 FISTP m32 FISTP m64

16 32 64

m<15:0> ST0 {int16 flp80}; next ST ST+1



Dziesiętne zapamiętanie ST0

FBSTP m80 80 m<80:0> ST0 {pdec flp80}; next ST ST+1

Zamiana zawartości rejestrów

FXCH STi 80 ST0 STi

Tab.5.20. Rozkazy badania argumentów FPU

Nazwa Mnemonik Wielkość argumentów

Działanie

Porównanie z liczbą zmiennoprzecinkową

FCOM STi FCOM m32 FCOM m64

80 32 64

C3,C2,C0 wg (ST0 - STi) {flp80-flp80}

C3,C2,C0 wg (ST0 - m<31:0>) {flp80-flp32}

C3,C2,C0 wg (ST0 - m<63:0>) {flp80-flp64}

Porównanie z liczbą zmiennoprzecinkową i zdjęcie ze stosu

FCOMP STi FCOMP m32 FCOMP m64

80

32

64

C3,C2,C0 wg (ST0 - STi) {flp80-flp80};

next ST ST+1

C3,C2,C0 wg (ST0 - m<31:0>) {flp80-flp32};

next ST ST+1

C3,C2,C0 wg (ST0 - m<63:0>) {flp80-flp64};

next ST ST+1

Porównanie z liczbą w ST1

FCOMPP 80 C3,C2,C0 wg (ST0 - ST1) {flp80-flp80};

next ST ST+2

Porównanie nieuporządkowane

FUCOM FUCOM STi

80 80

C3,C2,C0 wg (ST0 - ST1) {flp80-flp80}

C3,C2,C0 wg (ST0 - STi) {flp80-flp80}

Porównanie nieuporządkowane i zdjęcie ze stosu

FUCOMP FUCOMP STi

80

80

C3,C2,C0 wg (ST0 - ST1) {flp80-flp80};

next ST ST+1

C3,C2,C0 wg (ST0 - STi) {flp80-flp80};

next ST ST+1

Porównanie z ST1 (nieuporządkowane)

FUCOMPP 80 C3,C2,C0 wg (ST0 - ST1) {flp80-flp80};

next ST ST+2

Porównanie z liczbą całkowitą

FICOM m 16 32

C3,C2,C0 wg (ST0 - m<15:0>) {flp80-int16}

C3,C2,C0 wg (ST0 - m<31:0>) {flp80-int32}

Porównanie z liczbą całkowitą i zdjęcie ze stosu

FICOMP m

16

32

C3,C2,C0 wg (ST0 - m<15:0>) {flp80-int16};

next ST ST+1

C3,C2,C0 wg (ST0 - m<31:0>) {flp80-int32};

next ST ST+1

Porównanie z zerem FTST C3,C2,C0 wg (ST0 - 0)

Badanie rodzaju argumentu

FXAM C1 ST0<0>;

C3,C2,C0 wg rodzaju argumentu


Tab.5.21. Ustawienia bitów rodzaju wyniku w rozkazach porównania argumentów FPU.

Relacja C3 C2 C0

ST0 > arg 0 0 0

ST0 < arg 0 0 1

ST0 = arg 1 0 0

ST0 ? arg 1 1 1

Tab.5.22. Ustawienia bitów rodzaju wyniku w rozkazie FXAM

Zawartość ST0 C3 C2 C0

Liczba nieznormalizowana 0 0 0

Nieliczba 0 0 1

Liczba znormalizowana 0 1 0

Nieskończoność 0 1 1

Zero 1 0 0

Rejestr pusty 1 0 1

Liczba zdenormalizowana 1 1 0

Rejestr pusty 1 1 1

Tab.5.23. Rozkazy ładowania stałych FPU

Nazwa Mnemonik Wielkość argumentów

Działanie

Ładowanie zera FLDZ 80 ST ST-1; next ST0 0

Ładowanie jedności FLD1 80 ST ST-1; next ST0 1

Ładowanie liczby pi FLDPI 80 ST ST-1; next ST0

Ładowanie log210 FLDL2T 80 ST ST-1; next ST0 log210

Ładowanie log2e FLDL2E 80 ST ST-1; next ST0 log2e

Ładowanie log102 FLDLG2 80 ST ST-1; next ST0 log102

Ładowanie loge2 FLDLN2 80 ST ST-1; next ST0 loge2


Tab.5.24. Rozkazy arytmetyczne FPU


Działanie

Dodawanie zmiennoprzecinkowe

FADD FADD STi,ST FADD ST,STi FADD m32 FADD m64

80 80 80 32 64

ST1 ST1 + ST0; next ST ST+1

STi STi + ST0

ST0 ST0 + STi

ST0 ST0 + m32 {flp80 + flp32}

ST0 ST0 + m64 {flp80 + flp64}

Dodawanie zmiennoprzecinkowe ze zdjęciem ze stosu

FADDP STi,ST 80 STi STi + ST0; next ST ST+1

Dodawanie zmiennoprzecinkowe liczby całkowitej

FIADD m16 FIADD m32

16 32

ST0 ST0 + m16 {flp80 + int16}

ST0 ST0 + m32 {flp80 + int32}

Odejmowanie zmiennoprzecinkowe

FSUB FSUB STi,ST FSUB ST,STi FSUB m32 FSUB m64

80 80 80 32 64

ST1 ST1 - ST0; next ST ST+1

STi STi - ST0

ST0 ST0 - STi

ST0 ST0 - m32 {flp80 - flp32}

ST0 ST0 - m64 {flp80 - flp64}

Odejmowanie zmiennoprzecinkowe ze zdjęciem ze stosu

FSUBP STi,ST 80 STi STi - ST0; next ST ST+1

Odejmowanie zmiennoprzecinkowe liczby całkowitej

FISUB m16 FISUB m32

16 32

ST0 ST0 - m16 {flp80 - int16}

ST0 ST0 - m32 {flp80 - int32}

Odejmowanie odwrotne zmiennoprzecinkowe

FSUBR FSUBR STi,ST FSUBR ST,STi FSUBR m32 FSUBR m64

80 80 80 32 64

ST1 ST0 - ST1; next ST ST+1

STi ST0 - STi

ST0 STi - ST0

ST0 m32 - ST0 {flp32 - flp80}

ST0 m64 - ST0 {flp64 - flp80}

Odejmowanie odwrotne zmiennoprzecinkowe ze zdjęciem ze stosu

FSUBRP STi,ST 80 STi ST0 - STi; next ST ST+1

Odejmowanie odwrotne zmiennoprzecinkowe liczby całkowitej

FISUBR m16 FISUBR m32

16 32

ST0 m16 - ST0 {int16 - flp80}

ST0 m32 - ST0 {int32 - flp80}

Mnożenie zmiennoprzecinkowe

FMUL FMUL STi,ST FMUL ST,STi FMUL m32 FMUL m64

80 80 80 32 64

ST1 ST1 * ST0; next ST ST+1

STi STi * ST0

ST0 ST0 * STi

ST0 ST0 * m32 {flp80 * flp32}

ST0 ST0 * m64 {flp80 * flp64}

Mnożenie zmiennoprzecinkowe ze zdjęciem ze stosu

FMULP STi,ST 80 STi STi * ST0; next ST ST+1

Mnożenie zmiennoprzecinkowe liczby całkowitej

FIMUL m16 FIMUL m32

16 32

ST0 ST0 * m16 {flp80 * int16}

ST0 ST0 * m32 {flp80 * int32}

Dzielenie zmiennoprzecinkowe

FDIV FDIV STi,ST FDIV ST,STi FDIV m32 FDIV m64

80 80 80 32 64

ST1 ST1/ST0; next ST ST+1

STi STi/ST0

ST0 ST0/STi

ST0 ST0/m32 {flp80/flp32}

ST0 ST0/m64 {flp80/flp64}

Dzielenie zmiennoprzecinkowe ze zdjęciem ze stosu

FDIVP STi,ST 80 STi STi/ST0; next ST ST+1


Dzielenie przez liczbę całkowitą

FIDIV m16 FIDIV m32

16 32

ST0 ST0/m16 {flp80/int16}

ST0 ST0/m32 {flp80/int32}

Dzielenie odwrotne zmiennoprzecinkowe

FDIVR STi,ST FDIVR ST,STi FDIVR m32 FDIVR m64

80 80 32 64

STi ST0/STi

ST0 STi/ST0

ST0 m<31:0>/ST0 {flp32/flp80}

ST0 m<63:0>/ST0 {flp64/flp80}

Dzielenie odwrotne zmiennoprzecinkowe ze zdjęciem ze stosu

FDIVRP STi,ST 80 STi ST0/STi; next ST ST+1

Dzielenie odwrotne liczby całkowitej

FIDIVR m16 FIDIVR m32

16 32

ST0 m16/ST0 {int16/flp80}

ST0 m32/ST0 {int32/flp80}

Pierwiastek kwadratowy FSQRT 80 ST0 sqrt (ST0)

Mnożenie przez 2n FSCALE 80 ST0 ST0 * 2

[ST1]

Obliczanie wykładnika i mantysy ST0

FXTRACT 80 temp mantysa ST0; ST0

wykładnik ST0; next ST ST-1; next

ST0 temp

Obliczanie reszty z dzielenia FPREM 80 ST0 cz. ułamkowa (ST1/ST0)

Zaokrąglenie ST0 do liczby całkowitej

FRNDINT 80 Zaokrąglenie ST0 do liczby całkowitej wg reguły określonej w polu RC rejestru sterującego

Wartość absolutna ST0 FABS 80 ST0<79> 0 Zmiana znaku ST0 FCHS 80 ST0<79> not ST0<79>

Tab.5.25. Rozkazy obliczania funkcji FPU


Działanie

Obliczanie sinusa FSIN 80 ST0 sin ST0; next ST ST-1; next ST0 1

Obliczanie cosinusa FCOS 80 ST0 cos ST0; next ST ST-1; next ST0 1

Obliczanie sinusa i cosinusa

FSINCOS 80 ST0 sin ST0; temp cos ST0;

next ST ST-1; next ST0 temp

Obliczanie tangensa FPTAN 80 temp1/temp2 tg ST0; next ST0 temp2;

next ST ST-1; next ST0 temp2

Obliczanie arcus tangensa

FPATAN 80 ST0 arctg (ST1/ST0)

Obliczanie 2x - 1 F2XM1 80 ST0 2

ST0 - 1

Obliczanie y*log2x FYL2X 80 ST0 ST1*log2(ST0)

Obliczanie y*log2(x+1) FYL2XP1 80 ST0 ST1*log2(1+ST0)


Tab.5.26. Rozkazy sterujące FPU

Mnemonik

Działanie

FINIT Inicjacja koprocesora

FLDCW m16 Ładowanie rejestru sterowania koprocesora

FSTCW m16 Zapamiętanie rejestru sterowania koprocesora

FSTSW m16

FSTSW AX

Zapamiętanie rejestru stanu koprocesora

FCLEX Zerowanie znaczników błędów

FSAVE m Zapamiętanie zawartości koprocesora

FRSTOR m Ładowanie zawartości koprocesora

FSTENV m Zapamiętanie stanu koprocesora

FLDENV m Ładowanie stanu koprocesora

FINCSTP Zwiększenie wskaźnika stosu:

SP SP + 1 {mod 8}

FDECSTP Zmniejszenie wskaźnika stosu:

SP SP - 1 {mod 8}

FFREE STi Zwolnienie rejestru: tag_STi 11 {pusty}

FNOP Brak działania

FWAIT Oczekiwanie na gotowość koprocesora

Działania na danych upakowanych (MMX)

Rozkazy MMX korzystają z ośmiu 64-bitowych rejestrów MM0 .. MM7. Fizycznie, są to te same rejestry, które tworzą stos obliczeniowy jednostki zmiennoprzecinkowej ST0 .. ST7, a dokładnie: ich część <63:0> przeznaczona na przechowywanie mantysy.

Mnemoniki tych rozkazów są utworzone wokół mnemonika określającego podstawową operację (np. dodawanie - ADD, porównanie - CMP). Przedrostek P (packed data) wskazuje na rozkaz MMX, natomiast przyrostki precyzują format danych i sposób wykonania operacji:

B - spakowane bajty (8 bajtów w rejestrze), W - spakowane słowa (4 słowa w rejestrze), D - spakowane dwusłowa (2 słowa podwójne w rejestrze), Q - słowo czterokrotne, S - działanie z nasyceniem zachowującym znak, US - działanie z nasyceniem na liczbach bezznakowych.

Na przykład, rozkaz

PCMPEQW MM1,PINK

porównuje każde z 4 słów upakowanych w rejestrze MM1 z 16-bitowym wzorcem PINK i w przypadku wykrycia zgodności wpisuje do odpowiedniego fragmentu rejestru MM1 wartość FFFFh (true) a w przypadku niezgodności - wartość 0000h (false).

Ogólnie, rozkazy MMX realizują określoną operację jednocześnie na wszystkich argumentach upakowanych w 64-bitowym rejestrze; działanie takie jest określane jako SIMD (single instruction - multiple data). Ze względu na przewidywane zastosowania, niektóre operacje zamiast sygnalizowania nadmiaru dają wyniki „z nasyceniem” (saturated). Oznacza to, że jeżeli wynik przekracza zakres liczb, które mogą być przedstawione w danym formacie, to zapamiętywana jest najbliższa wartość graniczna. Np. dla 16-bitowych słów traktowanych jako liczba ze znakiem (w kodzie U2) przedział wartości jest od -2

15 (8000h) do 2

15-1 (7FFFh); te same słowa interpretowane jako liczba bez znaku

dają przedział wartości od 0 (0000h) do 216

-1 (FFFFh).


Tab.5.27. Rozkazy przesyłania danych MMX

Mnemonik

Działanie

MOV _ {D,Q} Przesłanie do/z rej MMX

PACKUSWB Pakowanie słów w bajty z nasyceniem bezznakowym

PACKSS_ _{WB,DW} Pakowanie słów w bajty lub słów podwójnych w słowa z nasyceniem znakowym

PUNPCKH_ _ {BW,WD,DQ} Rozpakowanie bardziej znaczących bajtów, słów lub słów podwójnych z rejestru MMX

PUNPCKL_ _{BW,WD,DQ} Rozpakowanie mniej znaczących bajtów, słów lub słów podwójnych z rejestru MMX

Tab.5.28. Rozkazy arytmetyczne MMX

Mnemonik

Działanie

PADD_ {B,W,D} Dodawanie bajtów, słów lub słów podwójnych

PADDS_ {B,W} Dodawanie bajtów lub słów, z nasyceniem

PADDUS_ {B,W} Dodawanie bajtów lub słów bez znaku, z nasyceniem

PSUB_ {B,W} Odejmowanie bajtów, słów lub słów podwójnych

PSUBS_ {B,W} Odejmowanie bajtów lub słów, z nasyceniem

PSUBUS_ {B,W} Odejmowanie bajtów lub słów bez znaku, z nasyceniem

PMULHW Mnożenie słów dla uzyskania bardziej znaczącej części iloczynu

PMULLW Mnożenie słów dla uzyskania mniej znaczącej część iloczynu

PMADDWD Mnożenie słów dla uzyskania obu części iloczynu

Tab.5.29. Rozkazy przesunięć MMX

Mnemonik

Działanie

PSLL_ {W,D,Q} Przesuniecie logiczne w lewo słów, słów podwójnych lub słowa poczwórnego.

PSRL_ {W,D,Q} Przesuniecie logiczne w prawo słów, słów podwójnych lub słowa poczwórnego.

PSRA_ {W,D} Przesuniecie arytmetyczne w prawo słów lub słów podwójnych.

Tab.5.30. Rozkazy logiczne MMX

Mnemonik

Działanie

PAND Bitowa operacja AND

PANDN Bitowa operacja AND NOT (mnożenie logiczne przez negację drugiego argumentu)

POR Bitowa operacja OR

PXOR Bitowa operacja XOR


Tab.5.31. Rozkazy porównań MMX

Mnemonik

Działanie

PCMPEQ_ {B,W,D} Porównanie bajtów, słów lub słów podwójnych i wpisanie true gdy równe wzorcowi, a false - gdy nie równe.

PCMPGT_ {B,W,D} Porównanie bajtów, słów lub słów podwójnych i wpisanie true gdy większe niż wzorzec, a false - gdy nie większe.

W grupie rozkazów MMX jest jeden rozkaz systemowy EMMS (empty mmx state) powodujący opróżnienie rejestrów MM0 ...MM7. Operacja ta jest wykonywana przez ustawienie pola stanu (Tag Field) wszystkich rejestrów jednostki zmiennoprzecinkowej w stan 11 („rejestr pusty”). Rozkaz EMMS powinien być wykonywany zawsze po zakończeniu działań MMX, ponieważ następujące ewentualnie później w programie rozkazy zmiennoprzecinkowe traktowałyby pozostawione w rejestrach MM dane jako poprawne liczby zmiennoprzecinkowe.


Entia non sunt multiplicanda praeter necessitatem.

William of Occam

Transputer - element sieci procesorów

Historia

Transputer i język occam (oryginalnie pisany małą literą!) przeznaczone do przetwarzania równoległego zostały opracowane łacznie przez brytyjską firmę INMOS Ltd. w r. 1983 (David May - język occam i lista rozkazów, Iann Barron - główny architekt).

Język occam bazuje na notacji C.A.R.Hoare’a dotyczącej procesów rónoległych (Communicating Sequential Processes, CSP, 1978). Programy w tym języku są budowane z trzech tylko podstawowych instrukcji:

v := e - przypisanie zmiennej v wyrażenia e,

c ! e - wysłanie wyrażenia e do kanału c,

c ? v - pobranie z kanału c zmiennej v.

Ta asceza syntaktyczna jest zgodna z dyrektywą metodologiczną znaną jako “brzytwa Ockhama” mówiącą iż nie należy mnożyć bytów ponad konieczność; stąd też wywodzi się nazwa języka.

Transputery mają układową realizację “kanałów”, dwa układy zegarów pomocnych przy przełaczaniu zadań oraz listę rozkazów dostosowaną do specyfiki języka occam, dzięki czemu program opisujący kilka procesów współbieżnych może być wykonywany na jednym transputerze – przez podział czasu między procesy, lub współbieżnie - na sieci transputerów połączonych szybkimi łączami komunikacyjnymi. Transputer jest układem scalonym zawierającym procesor typu RISC, wewnętrzną pamięć RAM, łącze pamięci zewnętrznej umożliwiające adresowanie w przestrzeni 4 GB i cztery szeregowe kanały we-wy pracujące na zasadzie bezpośredniego dostępu do pamięci (DMA), które służą do komunikacji z innymi transputerami tworzącymi sieć.

Pierwszy model transputera, T-414 (1985), miał procesor 32-bitowy i 2K-bajtową pamięć RAM; został on zastąpiony szybszą wersją T-800 z jednostką zmiennoprzecinkową, a później (1994) modelem T-9000 wyposażonym w jednostkę zmiennopozycyjną 64-bitową, pamięć wewnętrzną 16 KB i kanały o przepustowości 100 Mb/s. Istniała również wersja T-212 ze słowem 16-bitowym.

Są trzy grupy zastosowań transputerów:

w kartach akceleratorów graficznych do komputerów osobistych i stacji roboczych,

jako układy wbudowane (embedded) – np. w sterownikach drukarek laserowych,

jako samodzielne komputery o działaniu rónoległym zawierające do kilkuset transputerów - np. T.Node (64 transputery), MEGA Node (od 128 do 1024 transputerów).


Rejestry procesora

Model procesora w transputerze przedstawia rys.6.1.

Pamięć (M)

31.. 0 7F FF FF FF

Areg ... Obszar wolny

Breg

Creg Obszar roboczy

Oreg

Wptr Program

Iptr ...

80 00 00 00 Zmienne systemowe

Rys.6.1. Transputer. Podstawowe rejestry.

Wszystkie rejestry są 32-bitowe.

Rejestry Areg, Breg i Creg (oznaczane też A, B, C) tworzą stos obliczeniowy używany do przechowywania argumentów operacji.

Rejestr Iptr (Instruction Pointer, oznaczany też I) spełnia rolę licznika rozkazów wskazując adres rozkazu, który ma być wykonany. Rozkazy są 8-bitowe.

Rejestr Oreg (Operand register, oznaczany też O) przechowuje argument rozkazu; w niektórych przypadkach zawartość Oreg stanowi rozszerzenie kodu operacji. W fazie pobrania rozkazu z pamięci, 4 mniej znaczące bity rozkazu (pole Data) są zawsze przesyłane do Oreg.

Rejestr Wptr (Workspace pointer, oznaczany też W) wskazuje adres początkowy (bazę) obszaru roboczego zawierającego zmienne lokalne aktywnego procesu. Adres w Wptr dotyczy 32-bitowego słowa.

Procesor utrzymuje dwie kolejki procesów (zdefiniowanych przez ich obszary robocze); początek kolejki o wyższym priorytecie (kodowanym jako 0) wskazuje rejestr FPtrReg0 a kolejki o niższym priorytecie (kodowanym jako 1) - rejestr FPtrReg1, odpowiednio końce tych kolejek pokazują rejestry BPtrReg0 i BPtrReg1. Z każdym priorytetem związane są 3 rejestry obsługi zdarzeń uwarunkowanych czasowo:

ClockReg0 i ClockReg1 - rejestry zegara,

TPtrLoc0 i TPtrLoc1 - rejestry wskazujące pierwszą pozycję w kolejce procesów zawieszonych ze względu na czas,

TNextReg0 i TNextReg1 - rejestry wskazujące czas następnego zdarzenia.

Dwa jednobitowe znaczniki TEnabled0 i TEnabled1 wskazują czy odpowiednie kolejki czasowe nie są puste.

Znaczniki E (Error flag) i H (Halt-on-error flag) są stosowane przy obsłudze nadmiaru.

Transputer nie ma konwencjonalnych znaczników warunków; skoki warunkowe badają stan rejestru Areg.

Adresy pamięci traktowane są jako liczby w kodzie uzupełnieniowym z zakresu (szesnastkowo) 7FFF FFFF .. 8000 0000. Pozycje "na dole" pamięci (adresy 8000 0000 .. 8000 001C) są zarezerwowane do


obsługi kanałów wejścia-wyjścia. Pamięć wewnętrzna (implementowana w układzie scalonym razem z procesorem) jest umieszczana logicznie w dolnym obszarze adresów, co pozwala w czasie pracy na szybki dostęp do kodu programu bez sięgania do pamięci zewnętrznej. Alokacja pamięci ma miejsce w czasie kompilacji programu w języku occam.

Format rozkazu

Podstawowy format rozkazu przedstawia rys.6.2. Cztery bardziej znaczące bity rozkazu zawierają kod operacji (Function), pozostałe cztery bity stanowią argument (Data).

7 6 5 4 3 2 1 0

Function Data

Rys.6.2. Transputer. Format rozkazu.

W formacie podstawowym zakodowano 16 najczęściej stosowanych rozkazów a wśród nich 3 rozkazy specjalne: opr (Operate), pfix (Prefix) i nfix (Negative prefix).

Rozkazy pfix i nfix sluża do przygotowania zawartośći rejestru Oreg; rozkazy te, w przeciwienstwie do wszystkich innych, po wykonaniu nie zerują Oreg.

Rozkaz pfix wpisuje swoje pole Data na 4 mn.zn. bity Oreg i przesuwa zawartość tego rejestru o 4 pozycje w lewo:

7 3 0

Rozkaz pfix 0010 Data

31

Rejestr Oreg

3

0

Rozkaz nfix działa analogicznie, lecz przed przesunieciem Oreg uzupełnia (uzupełnienie logiczne) jego zawartość.

Rozkaz Operate umożliwia zwiększenie liczby rozkazów ponad 16, gdyż jego działanie zależy od argumentu zawartego w rejestrze Oreg stanowiacego w tym przypadku rozszerzenie kodu operacji. W transputerze stosowane są rozkazy opr z argumentem 4- i 8-bitowym.

Rozkaz opr z argumentem 4-bitowym jest kodowany w jednym bajcie (argument w polu Data jest automatycznie przenoszony do Oreg), natomiast rozkaz opr z argumentem 8-bitowym musi być poprzedzony rozkazem pfix przygotowującym w Oreg 4 b.zn. bity argumentu.

W transputerze stosowane są 3 sposoby adresacji:

natychmiastowa,

względna,

pośrednia rejestrowa.

Adresacja natychmiastowa dotyczy argumentu bezpośredniego zawartego w Oreg i miejscem przeznaczenia może być jedynie stos obliczeniowy. W przypadku argumentu mniejszego od 16 (dziesiętnie) stała może być umieszczona w jednobajtowym rozkazie. Np. rozkaz zwiększenia

zawartości akumulatora o 7 (adc 7) powoduje standardowe wpisanie pola danych do Oreg (Oreg 7)

i następnie dodanie Oreg do akumulatora (Areg Areg + Oreg).

Adresacja względna jest stosowana jedynie w rozkazach skokowych. Przesunięcie (displacement) pobierane, jak poprzednio, z rejestru Oreg jest traktowane jako liczba ze znakiem dodawana do zawartośći Iptr. Np. skok z przesunieciem –3D7 (hex) wymaga sekwencji rozkazów:

pfix 3

nfix D

j 9


Zawartość rejestru Oreg w kolejnych krokach zmienia się następująco:

stan początkowy 00000000

po pobraniu pfix 3 00000003

po wykonaniu pfix 3 00000030

po pobraniu nfix D 0000003C

po wykonaniu nfix D FFFFFC20

po pobraniu j 9 FFFFFC29 = - 3D7 (hex)

Adresacja pośrednia odbywa się za pośrednictwem rejestrow Wptr (adresacja lokalna) lub Areg (adresacja nie-lokalna) przechowujących adres bazowy, do którego jest ewentualnie dodawane przesuniecie z Oreg. Przesuniecie jest liczone w słowach 32-bitowych. Np. rozkaz ładowania lokalnego ldl powoduje przesuniecie stosu w dół

Creg Breg; Breg Areg

i wpisanie do Areg słowa z pamięci

Areg M[Wreg + 4*Oreg].

Rozkaz pamiętania nie-lokalnego stnl przesyła słowo z Breg do pamięci

M[Areg + 4*Oreg] Breg

i zmienia zawartość stosu:

Areg Creg, Breg 0, Creg 0.

Lista rozkazów

Transputer ma listę ok. 90 rozkazów, z których 16 stanowi listę podstawową rozkazów kodowanych w jednym bajcie.

Poniżej omowiono szczegółowo działanie rozkazów podstawowych a nastepnie podano zestaw wszystkich kodów rozkazowych transputera zgrupowanych według ich funkcji w programie. Ocenia się, że rozkazy podstawowe stanowią ok. 80% rozkazów wykonywanych w typowych programach; wzgląd na częstotliwość występowania był kryterium doboru kodów operacyjnych.

Podstawowa lista rozkazów

Spośród 16 rozkazów podstawowych 2 rozkazy (pfix i nfix) służą do przygotowania argumentu w rejestrze Oreg. Argument ten, zależnie od rozkazu podstawowego, pełni rolę stałej, adresu (przesunięcia) lub dodatkowego kodu operacji.


Tab. 6.1. Transputer. Podstawowa lista rozkazów.

Kod

Mnemonik (nazwa)

Działanie

0 j (jump)

Iptr Iptr + Oreg

1 ldlp (load local pointer)

Creg Breg; next Breg Areg; next

Areg Wptr + 0reg

2 pfix (prefix)

Oreg<3:0> data4; next

Oreg 4 shl Oreg

3 ldnl (load non-local)

Areg M[Aptr+4*Oreg]

4 ldc (load constant)

Creg Breg; next Breg Areg; next

Areg Oreg

5 ldnlp (load non-local pointer)

Areg Areg + 4*Oreg

6 nfix (negative prefix)

Oreg<3:0> data4; next

Oreg not Oreg; next

Oreg 4 shl Oreg

7 ldl (load local)

Creg Breg; next

Breg Areg; next

Areg M[Wptr+4*Oreg];

8 adc (add constant)

Areg Areg + Oreg

9 call (call)

Wptr Wptr - 4*4; next

M[Wptr] Iptr;

M[Wptr+1*4] Areg;

M[Wptr+2*4] Breg;

M[Wptr+3*4] Creg; next

Iptr Iptr + Oreg

A cj (conditional jump)

(Areg eql Oreg) => Iptr Iptr+Oreg;next

Areg 0;

(Areg neq Oreg) => Areg Breg; next

Breg Creg

B ajw (adjust workspace)

Wptr Wptr + 4*Oreg

C eqc (equals constant)

Areg (Areg eql Oreg)

D stl (store local)

M[Wptr+4*Oreg] Areg; next

Areg Breg; next

Breg Creg;next Creg 0

E stnl (store non-local)

M[Areg+4*Oreg] Breg; next

Areg Creg; next Breg O; Creg 0

F opr (operate)

Zależy od Oreg

Trzeci rozkaz specjalny z listy podstawowej, rozkaz opr rozszerza listę o dwie dalsze grupy rozkazów: z dodatkowym kodem 1-cyfrowym (oznaczenie F/ n0) i 2-cyfrowym (oznaczenie F/ n1 n0).

Rozkazy z kodem 2-cyfrowym wymagają wykonania sekwencji dwóch rozkazów 1-bajtowych:

pfix n1 (kod 2 n1)

opr n0 (kod F n0).

Rozkazy przesłań

Rozkazy przesłań (tab.6.2) dzielą się na lokalne (z lub do obszaru roboczego, adresacja względem Wptr) i nie-lokalne (adresacja względem Areg). Z reguły przesłania odbywają się do lub z Areg a zawartość stosu obliczeniowego jest przesuwana w górę lub w dół.


Rozkaz sb zapamiętuje bajt z Breg pod adresem wskazanym w Areg i zeruje stos:

M[Areg] Breg<7:0>; next

Areg Creg; next Breg 0 ; next Creg 0

Rozkaz lb wpisuje bajt z pamięci uzupełniony zerami do Areg:

Areg M[Areg]<7:0>.

Tab. 6.2. Transputer. Rozkazy przesłań.

Kod

Mnemonik (nazwa)

Działanie

7 ldl (load local)

Ładowanie lokalne

3 ldnl (load non local)

Ładowanie nie-lokalne

1 ldlp (load local pointer)

Ładowanie lokalne wskaźnika

5 ldnlp (load non local pointer)

Ładowanie nie-lokalne wskaźnika

F/1B ldpi (load pointer to instruction)

Ładowanie wskaźnika rozkazu

4 ldc (load constant)

Ładowanie stałej

F/42 mint (minimum integer)

Wpisanie minimalnej wartosci MinInt = -2

31

F/1 lb (load byte)

Ładowanie bajta (uzupełnionego zerami)

F/2 bsub (byte subscript)

Wskaźnik bajta (Areg + Breg)

F/A wsub (word subscript)

Wskaźnik słowa (Areg + 4*Breg)

D stl (store local)

Pamiętanie lokalne

E stnl (store non local)

Pamiętanie nie-lokalne

F/3B sb (store byte)

Pamiętanie bajta

F/0 rev (reverse)

Wymiana Areg i Breg

B ajw (adjust workspace)

Korekcja Wptr (dodanie 4*Oreg)

F/3C gajw (general adjust workspace)

Wymiana Areg i Wptr

Rozkaz mint ładuje stałą równą najmniejszemu adresowi pamięci (MinInt = 80000000h):

Areg MinInt

Rozkaz rev zamienia miejscami zawartość rejestrów Areg i Breg, natomiast gajw zamienia miejscami zawartość Areg i Wreg.

Rozkazy bsub i wsub traktują zawartość Areg jako adres początkowy struktury danych i powiększają go odpowiednio o liczbę bajtów lub liczbę słów podaną w Breg:

bsub => Areg Areg + Breg,

wsub => Areg Areg + 4*Breg.

Rozkaz ldpi wpisuje wskaźnik rozkazu do Areg:

Areg Areg + Iptr.



Rozkazy arytmetyczne (tab.6.3) obejmują cztery działania podstawowe, przy czym dzielą się na takie, które ustawiają znacznik E w przypadku nadmiaru (np. add, sub, mul, div) i takie, które ignorują błędy wykonania (np. sum, diff, prod).

Działania można wykonywać na pojedyńczych słowach (zapisanych w Areg i Breg) bez uwzględniania przeniesień lub argumenty mogą być wielosłowowe ("długie") i wówczas konieczne jest uwzględnienie przeniesień z poprzedniej operacji. Np. add jest dodawaniem jednosłowowym natomiast ladd jest dodawaniem wielosłowowym, przy czym przeniesienie jest pamiętane jako najmniej znaczący bit Creg.

Tab. 6.3. Transputer. Rozkazy arytmetyczne

Kod

Mnemonik (nazwa)

Działanie

F/5 add (add)

Dodawanie

F/52 sum (sum)

Suma

F/16 ladd (long add)

Dodawanie długie

F/37 lsum (long sum)

Suma długa

8 adc (add constant)

Dodawanie stałej

F/C sub (subtract)

Odejmowanie

F/4 diff (difference)

Różnica

F/38 lsub (long subtract)

Odejmowanie długie

F/4F ldiff (long difference)

Różnica długa

F/53 mul (multiply)

Mnożenie

F/8 prod (product)

Iloczyn

F/31 lmul (long multiply)

Mnożenie długie

F/2C div (divide)

Dzielenie

F/1F rem (remainder)

Reszta

F/1A ldiv (long divide)

Dzielenie długie

Rozkazy logiczne

Rozkazy logiczne (tab.6.4), podobnie do arytmetycznych, wykonują się na zawartośći górnych rejestrów stosu obliczeniowego. Przesunięcia dotyczą Breg lub połączonych rejestrow Creg, Breg (przesunięcia długie lshl, lshr); liczba przesunięć jest podana w Areg. Normalizacja (norm) polega na przesuwaniu w lewo rejestrów Breg, Areg aż do spotkania pierwszej jedynki; liczba przesunięć jest zliczana w Creg.


Tab. 6.4.Transputer. Rozkazy logiczne.

Kod

Mnemonik (nazwa)

Działanie

F/32 not (bitwise not)

Uzupełnienie logiczne

F/46 and (logical and)

Iloczyn logiczny

F/4B or (logical or)

Suma logiczna

F/33 xor (exclusive or)

Różnica symetryczna

F/41 shl (shift left)

Przesunięcie w lewo

F/40 shr (shift right)

Przesunięcie w prawo

F/36 lshl (long shift left)

Przesunięcie długie w lewo

F/35 lshr (long shift right)

Przesunięcie długie w prawo

F/19 norm (normalize)

Normalizacja

C eqc (equals constant)

Porównanie ze stałą i ustawienie Areg=1 gdy równe

F/9 gt (greater then)

Ustawienie Areg=1 gdy Breg>Areg

F/56 cword (check word)

Sprawdzenie Breg w stosunku do Areg i ustawienie E

F/13 csub0 (check subscript from 0)

Ustawienie E gdy Areg Breg

F/4D ccnt1 (check count from 1)

Ustawienie E gdy Areg < Breg lub Breg = 0

Rozkazy konwersji formatu

Pięć rozkazów konwersji formatu danych ma bardzo specyficzną realizację, odmienną od spotykanej w konwencjonalnych architekturach.

Rozkazy xword, xdble i csngl (tab. 6.5) zmieniają format danych zapisanych w rejestrach stosu obliczeniowego:

xword przepisuje zawartość Breg, traktowaną jako część słowa, do rejestru Areg z powieleniem bitu znakowego; długość danej w Breg musi być przed wykonaniem operacji zakodowana w Areg,

xdble zamienia 32-bitową stałą z Areg w liczbę 64-bitową zapisaną w Areg (część mniej znacząca) i Breg,

csngl ma działanie odwrotne do xdble, przy czym, w przypadku wystąpienia nadmiaru jest ustawiany znacznik błędu.

Rozkaz bcnt jest "licznikiem bajtów" w tym sensie, że mnoży zawartość Areg przez liczbę bajtów w słowie (dla procesorów 32-bitowych mnożnik ten wynosi 4).

Rozkaz wcnt przeprowadza dekompozycję adresu na część wskazującą adres słowa (zapisywaną w Areg) i część wskazującą bajt w słowie (zapisywaną w Breg).


Tab. 6.5. Transputer. Rozkazy zmiany formatu.

Kod

Mnemonik (nazwa)

Działanie

F/3A xword (extend to word)

Rozszerzenie do słowa z zachowaniem znaku

F/1D xdble (extend to double)

Rozszerzenie do podwójnego słowa

F/4C csngl (convert single)

Zamiana na format słowowy

F/34 bcnt (byte count)

Zmiana numeru słowa na numer bajta

F/3F wcnt (word count)

Dekompozycja adresu słowa

Rozkazy skoków

Skoki w transputerze (tab.6.6) są tylko względne, odległość (dodatnia lub ujemna) jest podana w Oreg.

Rozkaz gcall polega na zamianie Areg i Iptr:

Iptr Areg.

Powrót z podprogramu (ret) odtwarza tylko licznik rozkazów Iptr i wskaźnik obszaru roboczego Wptr, natomiast nie odtwarza stosu obliczeniowego zapamiętanego rozkazem call (tab.6.1):

Iptr M[Wptr]; next Wptr Wptr - 16.

Rozkaz lend służy do organizacji pętli programowych i w tym celu stosuje dwa słowa sterujące umieszczone kolejno poczynając od adresu M[Breg];drugie słowo jest licznikiem powtórzeń - wyjście z pętli następuje gdy licznik osiągnie wartość 1, w przeciwnym przypadku jest skok do początku pętli:

(M[Breg+4] > 1) => Iptr Iptr - Areg; next

M[Breg] [Breg] + 1;

M[Breg+4] M[Breg+4] - 1;

(M[Breg+4] < 1) => M[Breg+4] M[Breg+4] - 1.

Tab. 6.6. Transputer. Rozkazy skoków.

Kod

Mnemonik (nazwa)

Działanie

0 j (jump)

Skok

A cj conditional jump

Skok warunkowy

F/21 lend loop end

Pętla programowa

9 call call

Wywołanie procedury

F/6 gcall general call

Skok wg Areg

F/20 ret return

Powrót z procedury

Rozkazy komunikacji

Wśród rozkazów komunikacji (tab.6.7) istotną rolę przy komunikowaniu się procesów pełnią rozkazy in i out. Pozwalają one na wymianę komunikatów pomiędzy dwoma procesami poprzez tzw. kanał, czyli słowo w pamięci przydzielone tym procesom.


Po utworzeniu, kanał jest oznaczony jako "pusty" (empty). Przed wydaniem rozkazu in lub out na stosie muszą być przygotowane dane dotyczące komunikatu: jego długość (w Areg), adres początkowy komunikatu (w Creg) i wskaźnik kanału (w Breg). Pierwszy zgłaszający się proces znajduje kanał pusty, co oznacza, że nie może przeprowadzić transmisji. Następuje zapisanie stosu w obszarze roboczym a wskażnik tego obszaru zostaje umieszczony w kanale i proces zawiesza się. Jeżeli teraz do kanału zgłosi się drugi proces (in lub out) znajduje tam wskaźnik zawieszonego procesu i może przeprowadzić transmisję komunikatu; kanał zostaje ponownie oznaczony jako pusty a proces jest umieszczany na końcu kolejki procesów aktywnych. Analogicznie odbywa się komunikacja przez tzw. kanał zewnetrzny - gdy procesy są w rożnych transputerach i w transmisji muszą być zaangażowane łącza zewnętrzne DMA.

Rozkaz in realizuje instrukcję “c ? v” języka occam, rozkaz out - instrukcję “c ! e”, natomiast

podstawienie “v1 := v2” wykonuje się rozkazem move.

Rozkazy outword i outbyte przesyłają pojedyńcze słowo lub, odpowiednio, bajt z rejestru Areg przez kanał wskazywany w Breg.

Rozkazy enbc i disc sa stosowane przy realizacji instrukcji ALT.

Tab. 6.7. Transputer. Rozkazy komunikacji.

Kod

Mnemonik (nazwa)

Działanie

F/F outword (output word)

Wysłanie słowa

F/E outbyte (output byte)

Wysłanie bajta

F/7 in (input message)

Wpisanie do kanału

F/8 out (output message)

Odczyt z kanału

F/4A move (move message)

Przesłanie komunikatu

F/12 resetch (reset channel)

Wyzerowanie kanału

F/48 enbc (enable channel)

Otwarcie kanału gdy Areg=1

F/2F disc (disable channel)

Otwarcie kanału gdy Breg=1

Rozkazy obsługi błędów

Ponieważ w transputerze skoki warunkowe mogą następować tylko w wyniku badania Areg, istnieje grupa rozkazów (tab. 6.8), które sprawdzają znaczniki błędow (E i H) i odpowiednio ustawiają zawartość Areg.

Tab. 6.8. Transputer. Rozkazy obsługi blędow.

Kod

Mnemonik (nazwa)

Działanie

F/29 testerr (test error false and clear)

Areg not E; next E 0,

F/55 stoperr (stop on error)

{zatrzymnie procesu gdy błąd (E=1)}

F/10 seterr (set error)

E 1

F/57 clrhalterr (clear halt-on-error)

H 0,

F/58 sethalterr (set halt-on-error)

H 1

F/59 testhalterr (test halt-on-error)

Areg H

F/2A testpranal (test processor analysing)

{Areg 1, gdy procesor był

analizowany; Areg 0, gdy był reset}


Rozkazy obsługi kolejek

W tab. 6.9 zestawiono rozkazy działające na wskaźnikach kolejek procesów aktywnych. Rozkazy te umożliwiają nadanie wartośći wskaźnikom początku (FPtrRegi) i końca (BPtrRegi) kolejek o priorytecie 0 (high) i 1 (low) a także zapamiętanie tych wskaźników.

Tab. 6.9. Transputer. Rozkazy obsługi kolejek.

Kod

Mnemonik (nazwa)

Działanie

F/18 sthf (store high priority front pointer)

FPtrReg0 Areg

F/1C stlf (store low priority front pointer)

FPtrReg1 Areg

F/50 sthb (store high priority back pointer)

BPtrReg0 Areg

F/17 stlb (store low priority back pointer)

BPtrReg1 Areg

F/3E saveh (save high priority queue registers)

M[Areg] FPtrReg0;

M[Areg+4] BPtrReg0

F/3D savel (save low priority queue registers)

M[Areg] FPtrReg1;

M[Areg+4] BPtrReg1

We wszystkich wymienionych rozkazach, po wykonaniu opisanych powyżej przesłań, stos obliczeniowy jest przesuwany "w górę":

Areg Breg; next

Breg Creg; next

Creg 0.

Na rys.6.1. pokazano przykład listy trzech oczekujących procesów. Proces jest zdefiniowany przez swój obszar roboczy (wp), fi pokazuje adres pierwszego rozkazu, gdy proces zacznie być wykonywany natomiast lp jest łącznikiem- pokazuje adres następnego elementu na liście procesów aktywnych. Słowa wp, fi i lp dotyczące pierwszego procesu są umieszczone pod adresami FPtrReg0, FPtrReg0 - 4 i FPtrReg0 - 8.

wp1

FPtrReg0

fi1

lp1

- -

BPtrReg0

wp3

fi3

lp3

- -

wp2

fi2

lp2

Rys.6.1. Kolejka trzech procesów o priorytecie 0 (high).


Rozkazy zarządzania procesami

Istotną cechą transputera jest sprzętowa realizacja pewnych funkcji systemu operacyjnego związanych z szeregowaniem i obsługą procesów. Rozkazy podane w tab. 6.10. pozwalają inicjować wskazany proces czyli umieścić go na liscie procesów aktywnych (startp, runp) i kończyć proces (endp, stopp). Ponadto grupa rozkazów alt, altw, altend pozwala na realizację konstrukcji ALT języka occam służącej do wybrania z listy tego procesu, dla którego zostanie spełniony określony warunek (np. upływ czasu, dokonanie transmisji itp.).

Tab. 6.10. Transputer. Rozkazy zarządzania procesami.

Kod

Mnemonik (nazwa)

Działanie

F/D startp (start process)

Inicjacja procesu

F/3 endp (end process)

Zakończenie procesu

F/39 runp (run process)

Dopisanie procesu do kolejki

F/15 stopp (stop process)

Zatrzymanie procesu

F/1E ldpri (load current priority)

Wpisanie aktualnego priorytetu na stos obliczeniowy

F/43 alt (alt start)

Start alternatywy

F/44 altwt (alt wait)

Oczekiwanie alternatywy

F/45 altend (alt end)

Koniec alternatywy

F/49 enbs (enable skip)

Warunkowe (wg Areg) wybranie procesu

F/30 diss (disable skip)

Warunkowe (wg Breg) zablokowanie procesu

Rozkaz startp inicjuje nowy proces (z priorytetem bieżącego procesu). W Breg musi się znajdować adres względny (offset) pierwszego rozkazu tego nowego procesu a w Areg - adres jego obszaru roboczego. Działanie startp jest nastepujące:

(a) M[Areg-1*4] Iptr + Breg;

(b) M[BptrRegi-2*4] Areg;

(c) BptrRegi Areg.

Akcja (a) powoduje zapisanie adresu pierwszego rozkazu w drugim słowie obszaru roboczego nowego procesu, akcja (b) - wpisanie adresu nowego obszaru do trzeciego słowa procesu będącego na końcu kolejki i (c) - umieszczenie nowego procesu na końcu kolejki procesów aktywnych.

Rozkaz runp dopisuje wskazany proces do kolejki:

M[BptrRegi-2*4] Areg; BptrRegi Areg.

Rozkaz ldpri wpisuje do Areg kod bieżacego priorytetu: 0 - dla wysokiego, 1 - dla niskiego.

Inicjacja nowego procesu mającego obszar roboczy pod adresem WA i zaczynającego się rozkazem umieszczonym w pamięci pod adresem IA może być dokonana następującą sekwencją rozkazów:

(1) ldl IA

(2) ldl WA

(3) stnl -1

(4) ldl WA

(5) ldpri

(6) or

(7) runp.


Rozkazy (1) i (2) ładują na stos (do Areg i Breg) WA i IA a rozkaz (3) zapamiętuje w obszarze roboczym nowego procesu wartość IA (pod adresem Wptr-1*4). Rozkaz (4) jest potrzebny do odtworzenia zawartości Areg po wyzerowaniu przez (3). Rozkazy (5) i (6) tworzą w Areg deskryptor nowego procesu składający się z adresu obszaru roboczego (jest to adres pełnego słowa, więc zakończony ..00) i bieżącego priorytetu (0 lub 1) wpisanego na ostatnim bicie. Rozkaz (7) wstawia inicjowany proces na koniec kolejki procesów aktywnych.

Rozkazy obsługi zegara

Rozkazy talt, taltwt, enbt, dist (tab.6.11) obsługujące obydwa zegary dostępne w procesorze umożliwiają sterowanie procesami uwarunkowanymi czasowo, np. w konstrukcji ALT jezyka occam. Instrukcja ALT (alternative) umożliwia wykonanie tego procesu z listy, dla którego jako pierwszy zostanie spełniony podany warunek (przekazanie komunikatu z określonego kanału lub nadejście ustalonego czasu).

Tab. 6.11. Transputer. Rozkazy obsługi zegara.

Kod

Mnemonik (nazwa)

Działanie

F/22 ldtimer (load timer)

Zapamietanie zegara na stosie obliczeniowym

F/2B tin (timer input)

Oczekiwanie na chwilę określoną przez Areg

F/4E talt (timer alt start)

Start czasu alternatywy

F/51 taltwt (timer alt wait)

Oczekiwanie na alternatywę

F/47 enbt (enable timer)

Dopuszczenie zegara

F/2E dist (disable timer)

Zablokowanie zegara

F/54 sttimer (store timer)

Inicjacja zegarów

W grupie tej są też rozkazy spełniające elementarne funkcje inicjacji i pamiętania stanu zegarów a także opóźnienia programu.

Rozkaz ldtimer zapamiętuje na stosie obliczeniowym stan tego zegara, który ma priorytet równy priorytetowi bieżącego procesu:

Creg Breg; next

Breg Areg; next

Areg ClockRegi.

Rozkaz sttimer inicjuje obydwa zegary i uruchamia je; wartość początkowa pobierana jest z Areg :

ClockReg0 Areg; ClockReg1 Areg.

Za pomocą rozkazu tin można wprowadzić oczekiwanie na chwilę określoną przez zawartość Areg: rozkaz ten porównuje zawartość Areg z aktualnym stanem ClockRegi i jeżeli wyznaczony czas jeszcze nie minał, to proces jest usuwany z kolejki, w przeciwnym przypadku rozkaz nie powoduje żadnej akcji.


Λучше менше, да лучше.

В. И. Улянов (Ленин)

SPARC - architektura otwarta

Historia

SPARC (Scalable Processor Architecture) jest definicją “otwartej” architektury ogłoszoną przez Sum Microsystems w 1987r. Nie jest to nazwa konkretnej implementacji choć wiele procesorów i stacji roboczych ma ten skrót w swojej nazwie. Głównym architektem pierwszej, 32-bitowej wersji był Robert Garner. SPARC jest bezpośrednią adaptacją pionierskiej architektury mikroprocesorów opracowanych na Uniwersytecie w Berkeley - RISC I i RISC II (1982, Dave Patterson, Manolis Katevenis, Bob Sherburne), od których wywodzi się nazwa tego typu maszyn: Reduced Instruction Set Computers.

W ciągu ponad 10 lat od ogłoszenia sprawdziła się zarówno idea “skalowalności” jak i “otwartości”. O skalowalności świadczy fakt, że procesory SPARC są stosowane zarówno w notebookach, stacjach roboczych jak i w superkomputerach (np. SuperServer 6400 wyprodukowany przez Cray Research w 1993 r. był zbudowany z 64 procesorów SPARC). Pierwsze procesory Sun-4 zawierały 20 tys.bramek i pracowały z zegarem 16 MHz; UltraSPARC II (1995) jest procesorem superskalarnym o częstotliwości zegara 250 MHz i zawiera 3,8 mln tranzystorów. Druga cecha - otwartość architektury, polegająca na ogólnym udostępnieniu specyfikacji, zaowocowała jej realizacją przez kilkunastu producentów (n.b. pierwsze układy o architekturze SPARC były dostarczane przez Fujitsu w kwietniu 1986, przed oficjalną premierą Sun).

Szybkość procesora Sun SPARC-10 została przyjęta jako wartość odniesienia przy ocenie wydajności metodą programów testowych (SPECint95 i SPECfp95) przez Standard Performance Evaluation Corporation. W poprzedniej edycji tych testów, SPEC_92, tę rolę pełnił procesor VAX 11/780.

W 1994 r. ogłoszono, po 3 latach prac grupy SPARC Architecture Committee, wersję 64-bitową SPARC-V9 będącą podstawą współczesnych implementacji. Wersja V9 jest kompatybilana z 32-bitową wersją V8.

W ostatnich latach procesory Sun SPARC są wyposażane oprócz standardowej listy rozkazów stałoprzecinkowych, w rozkazy zmiennoprzecinkowe (formaty 32-, 64- i 128-bitowe) oraz w rozkazy VIS (Visual Instruction Set) realizujące jednoczesne działania na zestawie bajtów, półsłów i słów - podobnie jak to ma miejsce w rozkazach MMX w architekturze procesorów Intel x86.

Rejestry

Procesor dysponuje 32 rejestrami ogólnymi (general purpose registers) r0 .. r31 używanymi do przechowywania argumentów operacji i do adresowania pamięci oraz kilkoma rejestrami specjalnymi (special purpose registers) potrzebnymi do realizacji sterowania potokowego. Wszystkie rejestry są 32-bitowe.

Rejestry ogólne.

Rejestry ogólne są podzielone na 4 grupy po 8 rejestrów: rejestry globalne, wyjściowe, lokalne i wejściowe. W języku asemblera stosowane są następujące oznaczenia (w nawiasach oznaczenia alternatywne, nie zalecane):


%g0 .. %g7 - rejestry globalne (%r0 .. %r7)

%o0 .. %o7 - rejestry wyjściowe (%r8 .. %r15)

%l0 .. %l7 - rejestry lokalne (%r16 .. %r23)

%i0 .. %i7 - rejestry wejściowe (%r24 .. %r31)

Rejestry te są fizycznie zrealizowane w puli rejestrów, której wielkość zależy od implementacji i zwykle wynosi nie mniej niż 120. Liczba rejestrów w puli nie jest cechą architektury SPARC.

Rejestry aktualnie dostępne tworzą tzw. okno (register window). Po wywołaniu procedury następuje przemianowanie nazw rejestrów (rozkaz save) i udostępniane jest nowe okno w taki sposób, że “stare” rejestry wyjściowe stają się “nowymi” rejestrami wejściowymi. Rejestry globalne pozostają niezmienione. Przy powrocie z procedury (rozkaz restore) następuje przesunięcie okna w przeciwnym kierunku. Numer aktualnego okna jest zapisany w 5-bitowym polu rejestru stanu CWP (current window pointer) co określa maksymalną liczbę rejestrów w puli na 520 (32 okna).

Nakładanie się okien (rys.1) umożliwia szybkie przekazywanie parametrów - bez konieczności kontaktu z pamięcią operacyjną. W przypadku wyczerpania puli rejestrów (jej „przewinięcia” - rejestry fizyczne tworzą bufor cykliczny) następuje automatyczne przepisanie zajmowanego okna na stos. Na taką okoliczność każda procedura zawczasu rezerwuje miejsce na stosie rozkazem save. Przy powrocie z procedury (zwiększenie numeru okna) rejestry są automatycznie ładowane ze stosu.

Sytuacje wynikłe z wyczerpania puli rejestrów są obsługiwane przez system operacyjny powiadamiany odpowiednimi przerwaniami programowymi (traps) w czasie wykonywania rozkazów save i restore.

Niektóre rejestry mają swoje standardowe przeznaczenie i związane z tym nazwy stosowane w programach asemblerowych:

%g0 - zawiera stałą wartość 00000000h, zapis do niego jest ignorowany,

%sp := %o6 - wskaźnik stosu (stack pointer),

%fp := %i6 - wskaźnik ramki (frame pointer),

%i7 - zawiera adres powrotu (jego zawartość, jako %o7, jest przygotowywana rozkazem call przez procedurę wywołującą) .

Global

g0 (r0) ...

g7 (r7)

Global

Okno #(k-1)

Out

o0 (r8) ... o7 (r15)

Okno #k

Local

l0 (r16) ... l7 (r23)

o0 (r8) ...

o7 (r15)

Out

In

i0 (r24) ... i7 (r31)

l0 (r16) ...

l7 (r23)

Local

i0 (r24) ...

i7 (r31)

In

(Procedura wywołująca) (Procedura wywoływana)

Rys. 7.1. Okna rejestrów


Rejestry specjalne.

W związku ze specyficzną organizacją procesora, mającą wpływ na jego architekturę, w opisie działania rozkazów występują tzw. rejestry specjalne. W szczególności, ze względu na jawne uwzględnienie potokowości (pipelining) są dwa liczniki rozkazów:

PC - 32-bitowy wskaźnik aktualnego rozkazu (Program Counter)

nPC - 32-bitowy wskaźnik następnego rozkazu (next Program Counter)

Informacje o stanie procesora zawiera

PSR - 32-bitowy rejestr stanu procesora (Processor Status Register)

IMPL VER NZVC EC EF PIL S PS ET CWP

4 4 4 6 1 1 4 1 1 1 5

Znaczenie poszczególnych pól PSR jest następujące:

CWP - numer aktualnego okna rejestrów (current window pointer)

ET - otwarcie przerwań (traps enabled)

PS, S - poprzedni i aktualny tryb pracy (0 - user mode, 1 - supervisor mode)

PIL - maska przerwań (interrupt mask)

EF - włączenie jednostki zmiennoprzecinkowej (enable flp)

EC - włączenie koprocesora (enable coprocessor)

N,Z,V,C - znaczniki warunków (negative, zero, overflow, carry flags)

VER - wersja układu

IMPL - implementacja

Do rejestrów specjalnych należą ponadto:

WIM - rejestr zajętości okien (window invalid mask) wskazujący aktualnie zajęte rejestry fizyczne. Zawiera tyle bitów ile jest implementowanych okien, jedna „1” wskazuje pierwsze zajęte okno; próba ponownego zajęcia tego okna (np. w rozkazie restore lub save) powoduje przerwanie (trap) i w efekcie przepisanie okna do pamięci.

TBR - rejestr bazowy tablicy przerwań (trap base register) używany do przy określaniu adresu efektywnego programów obsługi pułapek warunkowych (rozkazy tcc).

Y - rejestr stosowany pomocniczo w rozkazach mnożenia i dzielenia (w rozszerzonej liście rozkazów).

Formaty rozkazów

Wszystkie rozkazy SPARC są 4-bajtowe i są zapisywane w pamięci wg zasdy big-endian z wyrównaniem adresu (adres rozkazu musi być podzielny przez 4).

Większość rozkazów, w tym wszystkie rozkazy arytmetyczne i logiczne, ma 3 argumenty umieszczone w rejestrach lub 2 argumenty w rejestrach a jeden - bezpośrednio dany w rozkazie. Operacje kodowane w tych rozkazach wykonują się wg formuły

dst src1 op src2

lub

dst src1 op imm13


Dla takich rozkazów, jak również dla rozkazów komunikujących się z pamięcią - load i store, są przeznaczone dwa podstawowe formaty:

31 30 29 25 24 19 18 14 13 12 5 4 0

f dst opc src1 0 (asi) src2

2 5 6 5 1 8 5

f dst opc src1 1 imm13

2-bitowe pole f odróżnia poszczególne formaty i pełni rolę pierwotnego kodu operacyjnego; w omawianych rozkazach pole f ma wartość 10 lub 11,

pole opc zawiera rozszerzenie kodu operacyjnego,

5-bitowe pola dst, src1 i src2 pozwalają adresować dowolny z 32 rejestrów roboczych,

8-bitowe pole <12:5> jest zarezerwowane; w niektórych rozkazach zapisuje się tam wskaźnik asi, określający jeden z 256 teoretycznie możliwych obszarów adresów (standardowo dostępne sa obszary danych, rozkazów, użytkownika i systemu),

jeżeli drugi argument źródłowy jest stałą, to zapisuje się go jako imm13 na bitach <12:0>,

ustawienie bitu <13> pozwala odróżnić format zawierający stałą imm13 od formatu wskazującego tylko rejestry.

Osobny format przewidziano dla 16 rozkazów skoków warunkowych (branch):

2 1 4 3 22

f a cnd op dsp22

00 010

Kod warunkujący efektywność skoku zapisany jest w 4-bitowym polu cnd,

pole dsp22 podaje względny adres skoku,

1-bitowe pole a (anul) wskazuje na sposób traktowania następnego rozkazu (wykonywanego jako rozkaz opóźnienia, po opóźnionym skoku).

Dwa rozkazy mają swoje specjalne formaty - rozkaz wywołania procedury (call) i specyficzny rozkaz stosowany przy formowaniu adresu (sethi).

W rozkazie call pole f pełni rolę kodu operacyjnego, dzięki czemu pozostaje 30 bitów na adres względny:

2 30

f dsp30

01

Ponieważ adresy rozkazów muszą być wyrównane (alligned) tzn. podzielne przez 4, więc 30-bitowy adres wystarcza do wskazania dowolnego miejsca w całej 4-Gbajtowej pamięci.

Drugi z unikatowych formatów przeznaczono dla rozkazu sethi (set high bits of address).W rozkazie tym występuje stała 22-bitowa, która jest przenoszona do bardziej znaczącej części rejestru wskazanego w polu dst:

2 5 3 22

f dst op imm22

00 100

Rozkaz sethi jest stosowany do kompletowania 32-bitowego słowa w rejestrze wybranym do dalszego wykorzystania jako rejestr adresowy.

Uwaga: pole imm22 bywa oznaczane jako iconst22 (integer constant), a pole imm13 - jako siconst13 (small integer constant).


Adres efektywny

Adres pamięci potrzebny jest tylko w rozkazach load i store oraz w rozkazach skoków (branch i call).

W rozkazach load i store stosowana jest adresacja pośrednia rejestrowa i adresacja względna. W pierwszym przypadku edres efektywny (e) jest sumą zawartości wskazanych rejestrów:

e = R[src1] + R[src2]

W adresacji względnej do zawartości rejestru dodawane jest 13-bitowe przesunięcie (stała imm13 traktowana jako liczba ze znakiem):

e = R[src1] + imm13 {tc}

Wielkość przesunięcia wynosi od -4096 do 4095 bajtów.

Oba sposoby adresacji dają specjalny efekt, gdy wskazany rejestr jest rejestrem %g0, który z definicji zawiera wartość 0. Adresacja rejestrowa przyjmuje wtedy prostą postać:

e = R[src2]

natomiast adresacja względna redukuje sie do adresacji bezwzględnej w dwóch obszarach po 4 KB każdy:

e = imm13 {tc}

“Górny“ obszar zawiera adresy od 00 00 00 00 do 00 00 0F FF; “dolny” obszar zawiera adresy od FF FF F0 00 do FF FF FF FF.

W rozkazach skoków stosowana jest adresacja względem PC

e = PC + 4 * dsp22 {tc}

Ponieważ dsp22 jest traktowane jako liczba ze znakiem i wskazuje odległość w słowach

(4-bajtowych), więc zasięg rozkazów skokowych jest 8MB względem adresu rozkazu.

Podobnie, w rozkazie call adres jest adresem względnym i zawsze dotyczy słów

e = PC + 4 * dsp30 {tc}

Dzięki temu zasięg rozkazu call wynosi 2Gbajty, co oznacza, że osiągalna jest cała przestrzeń adresowa.

Lista rozkazów

Przedstawiono podstawowe rozkazy w wersji 32-bitowej bez uwzględnienia działań zmienno-przecinkowych i dodanych później rozkazów mnożenia i dzielenia (rozkazy te w nowych wersjach nie są zalecane do stosowania).

W opisach przyjęto oznaczenie R/imm na oznaczenie drugiego argumentu źródłowego, którym może być zawartość rejestru R[src2] lub stała imm13 (w kodzie U2).

Rozkazy komunikacji z pamięcią

Są tylko dwa rodzaje działań na zawartości pamięci: ładowanie rejestru (load) i pamiętanie rejestru (store).

W rozkazach ładowania (tab.7.1) zawsze zmieniany jest cały 32-bitowy rejestr; w przypadku przesyłania bajta lub półsłowa (16 bitów) pozostałe pozycje rejestru są wypełniane zerami (ładowanie bezznakowe) lub powielonym bitem znakowym (ładowanie znakowe). Przy ładowaniu słowa podwójnego numer rejestru musi być parzysty.


Tab.7.1. Rozkazy ładowania.

ldsb Ładowanie znakowe bajta R[dst] M[e]<7:0>

ldsh Ładowanie znakowe półsłowa

R[dst] M[e]<15:0>

ldub Ładowanie bezznakowe bajta

R[dst] 000000^M[e]<7:0>

lduh Ładowanie bezznakowe półsłowa

R[dst] 0000^M[e]<15:0>

ld Ładowanie słowa R[dst] M[e]<31:0>

ldd Ładowanie podwójnego słowa

R[dst]^R[dst+1] M[e]<63:0>

W przeciwieństwie do rozkazów ładowania, przesyłać do pamięci można również fragmenty rejestrów - bajty i półsłowa. Rozkazy store (tab.7.2) nie zmieniają zawartości obsługiwanych rejestrów.

Tab.7.2. Rozkazy pamiętania.

stb Pamiętanie bajta M[e]<7:0> R[dst]<7:0>

sth Pamiętanie półsłowa M[e]<15:0> R[dst]<15:0>

st Pamiętanie słowa M[e]<31:0> R[dst]<31:0>

std Pamiętanie słowa podwójnego

M[e]<63:0> R[dst]^R[dst+1]

Dwa rozkazy ułatwiają synchronizację procesów przy przetwarzaniu równoległym (tab.7.3). Rozkaz ldstub ładuje (bezznakowo) wskazany bajt do rejestru a następnie na jego miejsce wpisuje do pamięci 11111111. Rozkaz swap wymienia miejscami zawartość zaadresowanego słowa ze wskazanym rejestrem.

Tab.7.3. Rozkazy pomocnicze w wieloprocesowości.

ldstub Ładowanie i zapis. R[dst] 000000h^M[e]<7:0>;

next M[e]<7:0> FFh

swap Wymiana słowa z rejestrem M[e]<31:0> R[dst]


Wszystkie rozkazy arytmetyczne (i logiczne) mają dwie wersje - bez ustawiania znaczników i z ustawianiem znaczników N, Z, V, C. Jeżeli ustawione warunki nie mają być później badane lepiej jest stosować wersje bez ustawiania znaczników (np. w tzw. rozkazach opóźnienia, występujących w programie po rozkazach skoków).

Z działań arytmetycznych stałoprzecinkowych (tab.4) dostępne jest tylko dodawanie i odejmowanie w kodzie uzupełnieniowym - bez uwzględniania ustawień znacznika C oraz z uwzględnieniem przeniesienia (pożyczki) z poprzednich operacji.

Rozkaz mulscc wykonuje jeden krok mnożenia: warunkowe dodawanie mnożnej (src2) do wyniku częściowego (dst) na podstawie badania jednego bitu mnożnika (src1). W praktyce, do obliczania iloczynu wykorzystuje się raczej działania jednostki zmiennoprzecinkowej.


Tab.7.4. Rozkazy arytmetyczne

add Dodawanie R[dst] R[src1] + R/imm

addcc Dodawanie i ustawianie znaczników

R[dst] R[src1] + R/imm; next N,Z,V,C

addx Dodawanie przeniesienia R[dst] R[src1] + R/imm+ C;

addxcc Dodawanie przeniesienia i ustawianie znaczników

R[dst] R[src1] + R/imm + C; next N,Z,V,C

sub Odejmowanie R[dst] R[src1] - R/imm

subcc Odejmowanie i ustawianie znaczników

R[dst] R[src1] - R/imm; next N,Z,V,C

subx Odejmowanie pożyczki R[dst] R[src1] - R/imm - C;

subxcc Odejmowanie pożyczki i ustawianie znaczników

R[dst] R[src1] - R/imm - C; next N,Z,V,C

mulscc Krok mnożenia i ustawianie znaczników

R[src1]<0> => R[dst] R[dst] + R/imm ; next N,Z,V,C

Rozkazy logiczne

Wyjątkowo rozbudowaną grupę rozkazów stanowią działania logiczne (tab.7.5). Oprócz iloczynu (and) i sumy logicznej (or) można, na odpowiadających sobie pozycjach słów 32-bitowych, wykonywać działania różnicy symetrycznej (xor) , równoważności (xnor), zanegowanej implikacji (andn) i zanegowanej kontrimplikacji (orn). każdy z tych rozkazów ma wersję ustawiającą znaczniki warunków. Niektóre z tych dość egzotycznych rozkazów znajdują zastosowanie do tworzenia użytecznych pseudorozkazów asemblerowych.

Tab.7.5. Rozkazy logiczne.

and Iloczyn logiczny R[dst] R[src1] and R/imm

andcc Iloczyn logiczny i ustawienie znaczników

R[dst] R[src1] and R/imm; next N,Z,V,C

andn Iloczyn logiczny z negacją R[dst] R[src1] and not R/imm

andncc Iloczyn logiczny z negacją i ustawienie znaczników

R[dst] R[src1] and not R/imm; next N,Z,V,C

or Suma logiczna R[dst] R[src1] or R/imm

orcc Suma logiczna i ustawienie znaczników

R[dst] R[src1] or R/imm; next N,Z,V,C

orn Suma logiczna z negacją R[dst] R[src1] or not R/imm

orncc Suma logiczna z negacją i ustawienie znaczników

R[dst] R[src1] or not R/imm; next N,Z,V,C

xor Różnica symetryczna R[dst] R[src1] xor R/imm

xorcc Różnica symetryczna i ustawienie znaczników

R[dst] R[src1] xor R/imm; next N,Z,V,C

xnor Różnica symetryczna z negacją

R[dst] R[src1] eqv R/imm

xnorcc Różnica symetryczna z negacją i ustawienie znaczników

R[dst] R[src1] eqv R/imm; next N,Z,V,C



Przesunięcia (tab.7.6) mogą dotyczyć dowolnego rejestru a liczbę przesunięć podaje się jako parametr. Dostępne są tylko 3 najczęściej stosowane rozkazy, nie ma rotacji. Nie jest ustawiany żaden znacznik.

Tab.7.6. Przesunięcia.

sll Przesuniecie w lewo R[dst] imm13 shl R[src1]

srl Przesunięcie w prawo R[dst] imm13 shr R[src1]

sra Przesuniecie arytmetyczne w prawo

R[dst] imm13 shra R[src1]

Rozkazy sterujące program

Najbardziej osobliwą grupę rozkazów stanowią rozkazy sterujące. Ich działanie (tab.7.7) wynika ze specyficznej organizacji i jest dostosowane do przewidzianego zastosowania w programie. Pewną niewygodę przy pisaniu programów łagodzą tzw. pseudorozkazy dostępne w języku asemblera, które symulują działanie typowych rozkazów znanych z konwencjonalnych asemblerów maszyn CISC.

Tab.7.7. Rozkazy sterujące.

b__ Skok warunkowy (16 wersji) temp PC + 4*dsp22; next PC nPC;

next (cnd => nPC temp)

jmpl Skok ze śladem R[dst] PC; next PC nPC; next

nPC R[src1] + R/imm

call Wywołanie procedury o7 PC; next PC nPC; next nPC nPC + 4*dsp30

save Przesunięcie okna rejestrów temp R[src1] + R/imm; next

CWP CWP - 1; next R[dst] temp

restore Odtworzenie okna rejestrów temp R[src1] + R/imm; next

CWP CWP + 1; next R[dst] temp

t__ Warunkowa pułapka (128 pułapek programowych)

cnd => (ET 0; PS S; next S 1;

CWP CWP-1; next %l1 PC;

%l2 nPC; next PC vector )

rett * Powrót z pułapki ET 1; PC nPC; next

nPC R[src1] + R/imm; next

CWP CWP + 1; S PS

* rozkaz uprzywilejowany

Skoki warunkowe (conditional branches) wykonują się zależnie od ustawionych znaczników N, Z, V, C. Ich nazwy (tab.8) odnoszą się do wyników porównania argumentów pseudorozkazem cmp A,B, w którym następuje odejmowanie B - A. Np. bgeu (branch if greater or equal, unsigned) wskazuje na

relację B A (drugi argument większy lub równy od pierwszego, obie liczby traktowane jako bezznakowe).

Skoki warunkowe są rozkazami opóźnionymi, tzn. przekazanie sterowania następuje dopiero po wykonaniu następnego rozkazu, nazywanego rozkazem opóźnienia (zwłoki).

Bit annul (w mnemoniku asemblerowym występujący jako przyrostek [,a]) określa traktowanie następnego rozkazu (rozkazu opóźnienia); jeżeli a=0 wówczas następny rozkaz jest wykonywany zawsze, jeżeli natomiast a=1 to następny rozkaz wykonywany jest tylko wtedy, gdy skok jest efektywny; jeżeli skok jest nieefektywny, wówczas rozkaz następny jest przeskakiwany. Takie działanie skoku można wykorzystać do optymalnego tworzenia pętli (branch na końcu pętli).

Rozkaz bn (never branch) jest podobny do nop, lecz w przypadku ustawienia bitu a rozkaz opóźnienia nie jest wykonywany.


Tab.7.8. Kodowanie rozkazów skoków warunkowych

Rozkaz

cnd

Stan znaczników

Warunek po porównaniu liczb

ze znakiem

Warunek po porównaniu liczb

bez znaku

bn 0000 0 = 1 Nigdy (never)

be (bz) 0001 Z = 1 B = A B = A

ble 0010 Z or (N xor V) = 1 A B -

bl 0011 N xor V = 1 A > B -

bleu 0100 Z or C = 1 - A B

bcs (blu) 0101 C = 1 - A > B

bneg 0110 N = 1 Ujemne (negative)

bvs 0111 V = 1 Nadmiar (overflow set)

ba 1000 1 = 1 Zawsze (always)

bne (bnz) 1001 Z = 0 B A B A

bg 1010 Z or (N xor V) = 0 B > A -

bge 1011 N xor V = 0 B A -

bgu 1100 Z or C = 0 - B > A

bcc (bgeu) 1101 C = 0 - B A

bpos 1110 N = 0 Dodatnie (positive)

bvc 1111 V = 0 Brak nadmiaru (overflow clear)

Rozkaz skoku ze śladem jmpl (jump and link) jest również rozkazem opóźnionym. Zapamiętuje on bieżący PC w rejestrze docelowym i przekazuje sterowanie pod wskazany adres; np.

jmpl etyk,%o3

przekazuje sterowanie do miejsca etyk, zapamiętując swój adres w rejestrze wyjściowym o3; zanim wykona się pierwszy rozkaz podprogramu, będzie wykonany rozkaz następujący w programie za jmpl (jego adres jest już w nPC). Powrót z podprogramu może nastąpić również rozkazem jmpl z adresacją pośrednią poprzez rejestr o3:

jmpl %o3+8,%g0

Rozkaz wywołania procedury call zapamiętuje swój adres (PC) w rejestrze wyjściowym o7 i przenosi sterowanie pod adres docelowy, natomiast nie zmienia okna.

Zmiana okna musi być wykonana rozkazem save w wywołanej procedurze. Rozkaz save ponadto inicjuje nowy wskaźnik stosu w rejestrze wyjściowym o6 dodając do starego sp (mieszczącego się teraz w i6) wartość imm13. Zapis asemblerowy jest nieco mylący ponieważ na oznaczenie obu rejestrów stosowany jest ten sam symbol %sp, np.:

save %sp,-120,%sp

Przesunięcie stosu ma na celu utworzenie tzw. ramki (frame), w której można będzie w przypadku przepełnienia puli rejestrów przechować rejestry z nowo zajmowanego okna; wskaźnikiem ramki (fp, frame pointer) jest „stary” sp w rejestrze i6. Ramka musi mieć co najmniej 64 bajty aby pomieścić 16 rejestrów okna (wejściowe i lokalne).

Przy wyjściu z procedury następuje przekazanie sterowania do rozkazu znajdującego się po call (a dokładnie: po rozkazie opóźnienia występującym po call) i przesunięcie okna rejestrów w przeciwnym kierunku (zwiększenie CWP). Czynności te są rozdzielone na dwa rozkazy: pseudorozkaz ret, realizowany jako rozkaz opóźniony jmpl, aktualizuje licznik rozkazów a następujący po nim - lecz realizowany wcześniej - rozkaz restore przesuwa okno rejestrów.

Przy takim działaniu rozkazów typowa konstrukcja procedury jest następująca:


program wywołujący umieszcza argumenty w swoich rejestrach wyjściowych %o0 .. %o5 (rejestry %o6 i %o7 są zarezerwowane dla %sp i adresu powrotu)

program wywołujący wykonuje sekwencję:

call piro ! %o7 PC, piro - nazwa procedury

nop ! rozkaz opóźniony

procedura tworzy ramkę na stosie i przesuwa okno rejestrów:

piro: save %sp,-64,%sp ! nowe okno, nowe sp

przekazane argumenty są dostępne w %i0 .. %i5

przed powrotem, procedura umieszcza zwracane wartości w rejestrach wejściowych, zmienia okno i umieszcza adres powrotu w PC:

ret ! skok do %i7 + 8

restore ! zmiana okna, wykonuje się przed ret

Rozkazy pułapek warunkowych (traps) sa obsługiwane analogicznie do wyjątków i przerwań zewnętrznych. Następuje przekazanie sterowania do programu nadzorczego (supervisor) przez tablicę pułapek, której adres jest w rejestrze specjalnym TBA. W rozkazie podaje się numer pułapki a nie adres obsługi. Powrót z pułapki następuje rozkazem rett.

Rozkaz sethi

Rozkaz sethi (set high bits of register) powoduje ustawienie 22 bardziej znaczących bitów rejestru z jednoczesnym wyzerowaniem pozostałych:

R[dst]<31:10> imm22; R[dst]<9:0> 0

Rozkaz ten jest stosowany do przygotowania adresu w rejestrze. Umieszczenie pełnej liczby 32-bitowej jednym rozkazem jest niemożliwe, gdyż cały rozkaz ma 32 bity, więc trzeba potrzebny adres składać częściami.

Np. aby w rejestrze l2 umieścić liczbę 9A7B5C3Dh najpierw wpisuje się 22 b.zn. bity (269ED7h) rozkazem sethi a następnie dołącza się pozostałe 10 bitów (03Dh) rozkazem or:

sethi 0x269ED7, %l2

or %l2,0x03D,%l2

W języku asemblera dostępne są operatory %hi i %lo, które wydzielają z argumentu część „wysoką” (high) i „niską” (low) ; przy zastosowaniu tych operatorów powyższe zadanie można zrealizować jako:

sethi %hi(0x9A7B5C3D), %l2

or %l2,%lo(0x9A7B5C3D),%l2

Przy wywoływaniu procedury korzystającej z tak przygotowanego adresu rozkaz or może być wykonywany jako rozkaz opóźnienia. Np. jeżeli procedura drkk potrzebuje adresu tkps umieszczonego w rejestrze o1, to jej wywołanie może być następujące:

sethi %hi(tkps), %o1 ! wpisanie 22 bitów do o1

call drkk ! wywołanie procedury drkk (rozkaz opóźniony)

or %o1,%lo(tkps),%o1 ! dopisanie pozostałych 10 bitów

! przed wykonaniem call (rozkaz opóźnienia)


Rozkazy specjalne

Rozkazy specjalne (tab.7.9) są wykonywane zwykle tylko w trybie supervisor, gdyż dotyczą zapisu i odczytu rejestrów specjalnych (np. WIM, PSR, TBR) i pamięci cache.

Tab.7.9. Rozkazy specjalne

rd Odczytanie zawartości rejestru specjalnego

wr Zapisanie do rejestru specjalnego

iflush Opróżnienie (flush) pamięci rozkazów

Rozkazy znakowane

Zmienne znakowane (tagged data) zawierają oprócz kodu liczbowego określającego ich wartość, dodatkowy kod określający ich typ - np. liczba stałoprzecinkowa, adres (liczba całkowita bez znaku), liczba zmiennoprzecinkowa. Budowa słowa zawierającego taką daną może być następująca:

30 2

wartość tag

Przy takim kodowaniu danych operacje mogą być ogólne, „rodzajowe” (generic). W konwencjonalnych listach rozkazów są np. osobne rozkazy dodawania stałoprzecinkowego i osobne rozkazy dodawania zmiennoprzecinkowego; stosując zmienne znakowane można użyć jednego rozkazu „dodawanie”, a nawet argumenty w tym rozkazie mogą być różnych typów.

Przewidziano tylko dwa działania: dodawanie (taddcc) i odejmowanie (tsubcc) liczb znakowanych. Każde z tych działań ustawia znaczniki N, Z, V, C. Osobne wersje (taddcctv, tsubcctv) powodują generowanie wyjątku (trap) przy nadmiarze.

Pseudorozkazy asemblera

W asemblerze można stosować pseudorozkazy, nazywane tu rozkazami syntetycznymi (synthetic instructions), które są wykonywane jako szczególne przypadki zwykłych rozkazów. Rozkazy syntetyczne realizują wiele często używanych działań powszechnie spotykanych w innych listach rozkazów. Bardzo pomocne okazuje się tu zastosowanie rejestru %g0 o stałej zawartości 0.

W tab.7.10. pokazano kilkanaście przykładów pseudorozkazów i odpowiadających im implementacji w standardowych rozkazach maszynowych.

Implementacja pseudorozkazu mov zależy od jego argumentów - dla rejestrów uniwersalnych stosowany jest rozkaz or, natomiast dla rejestrów specjalnych trzeba stosować rozkaz wr lub rd (w tablicy pokazano przykład odczytania rejestru WIM i wpisania stałej do rejestru stanu PSR).

Należy zwrócić uwagę, że w rozkazie porównania (cmp A,B), wykonuje się odejmowanie przestawionych argumentów: B - A (sub B,A,%g0). Do wyników takiego właśnie porównania nawiązują nazwy skoków warunkowych.

Testowanie rejestru (tst) polega na wykonaniu operacji

reg 0 or reg,

która nie zmienia zawartości rejestru ale ustawia znaczniki N, Z i C.

Uzupełnienie logiczne (not) wykorzystuje właściwość funkcji boolowskiej xor:

0 xor X = not X.

Zmianę znaku liczby (neg) uzyskuje się przez jej odjęcie od zera.

Inkrementacja (inc) i dekrementacja (dec) polega na dodaniu lub odjęciu 1.

Rozkaz ret (powrót z procedury) wpisuje do licznika rozkazów adres o 8 większy niż był adres powrotu umieszczony w %o7 przez rozkaz call; dzięki temu będzie wykonany rozkaz znajdujący się za


rozkazem opóźnienia występującym po call (call zostawił w %o7 swój adres wziety z PC, dwa kolejne rozkazy zajmują 8 bajtów).

Rozkazy skipz i skipnz przeskakują następny rozkaz zależnie od ustawienia znacznika zera (Z); w tej konstrukcji wykorzystano wersje skoków warunkowych z ustawionym bitem anulowania rozkazu opóźnienia (zapis asemblerowy .+k oznacza adres o k większy od adresu aktualnie wykonywanego rozkazu).

Pseudorozkaz set wykonuje wpisanie do wskazanego rejestru reg 32-bitowej stałej const; wykonuje się jako 2-rozkazowa sekwencja sethi i or. Jeżeli wartość stałej jest dostatecznie mała to optymalizowany asembler wybiera prostszą wersję jednorozkazową.

Tab. 7.10. Przykłady pseudorozkazów SPARC

Pseudorozkaz Rozkaz(y)

mov %regs, %regd or %g0,%regs,%regd

mov %wim, %reg rd %wim,%reg

mov const, %psr wr %g0,const,%psr

cmp %reg1, %reg2 subcc %reg2,%reg1,%g0

tst %reg orcc %g0,%reg,%g0

not %reg xnor %g0,%reg,%reg

neg %reg sub %g0,%reg,%reg

inc %reg add %reg,1,%reg

dec %reg sub %reg,1,%reg

clr %reg or %g0,%g0,%reg

restore restore %g0,%g0,%g0

ret jmpl %i7+8,%g0

jmp addr jmpl addr, %g0

skipz bnz,a .+8

skipnz bz,a .+8

set const,%reg sethi %hi(const),%reg

or %reg,%lo(const),%reg

- lub (wybiera asembler, gdy stała krótka) -

or %g0,const,%reg

nop sethi 0,%g0


Znaj proporcją, mocium panie.

Aleksander hr. Fredro

Ghibli - model prostego komputera

Model komputera, nazwanego Ghibli jest zmienioną wersją modelu SEN (Simple Educational von Neumann's Machine) poprzednio stosowanego przez autora do celów dydaktycznych i stanowi przykład architektury jedno-akumulatorowej z klasycznymi dla maszyn typu CISC sposobami adresowania argumentów w pamięci operacyjnej. Opisano go na poziomie architektury (Instruction-Set Architecture, IS) i struktury (Register-Transfer Level, RTL) z dokładnością do mikrooperacji oraz podano dla niego definicję języka asemblera nazwanego Ghibass.

Architektura

Architekturę komputera opisano słownie ilustrując przyjęte rozwiązania za pomocą diagramów, a następnie podano jej zapis formalny w przyjętej notacji (ISP).

Ogólna charakterystyka

Ghibli jest komputerem jednoadresowym o oddzielonej przestrzeni adresów pamięci i portów wejścia-wyjścia. Pamięć operacyjna (M) jest adresowana z dokładnością do 8-bitowego bajta i zawiera 64K bajty. Słowo 16-bitowe tworzą dwa kolejne bajty. Uporządkowanie bajtów w słowie jest typu big-endian - adres słowa jest adresem bardziej znaczącego bajta. Bity są numerowane od lewej (od bitu bardziej znaczącego).

0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15

Bajt bardziej znaczący (MSB) Bajt mniej znaczący (LSB)

(adres x) (adres x+1)

Rys.8.1. Słowo maszynowe.


Przestrzeń wejścia-wyjścia ma 256 portów wejściowych (IPT) i 256 portów wyjściowych (OPT), ośmiobitowych.

Adresy pamięci M Adresy portów we-wy IPT OPT

0 0

1 1

2 .

.

. 255

0.. ..7 0.. ..7 0.. ..7

.

65535

Rys.8.2. Przestrzeń adresowa.

Procesor ma trzy 16-bitowe rejestry programowe - akumulator (AC), licznik (wskaźnik) rozkazów (IP) i wskaźnik stosu (SP). W 16-bitowym słowie stanu (PS) jest zawartych 5 znaczników: C – przeniesienie, S – znak liczby, Z – zero, V – nadmiar, IE – maska przerwań.

0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15

C S Z V IE

Rys.8.3. Struktura słowa stanu PS.

Stos systemowy, używany do obsługi przerwań i w skokach do podprogramów, przechowuje tylko 2-bajtowe słowa i przyrasta w kierunku adresów malejących.

Adres

a-2

SP a-1 Szczyt stosu

a-1 a

a+1

a+2

Rys. 8.4. Stos systemowy w pamięci operacyjnej.

Po uruchomieniu wszystkie rejestry są zerowane, co oznacza, że pierwszy rozkaz pobierany jest spod adresu 0000h a pierwsze przesłanie na stos (o ile nie zostanie załadowany rejestr SP) następuje pod adres FFFEh.


Sygnał zgłoszenia przerwania (int) powoduje odłożenie na stos aktualnej zawartości PS i IP, wyzerowanie znacznika IE, a następnie przejście do programu obsługi spod adresu bezwzględnego 0003h.

Rozkazy mają długość 1, 2 lub 3 bajtów i są kodowane w jednym z 7 formatów interpretowanych zależnie od wartości kodu operacyjnego (op) zapisanego na pierwszych 4 bitach słowa rozkazowego i od sposobu adresacji kodowanego na bitach 4 i 5 tego słowa. W rozkazach bezadresowych i rozkazach we-wy kod operacyjny zapisuje się na 8 bitach (pole op i pole ope), co pozwala na rozbudowanie repertuaru tej grupy rozkazów.

Adres względny jest traktowany jako liczba z zakresu -512..+511, którą dodaje się do aktualnej zawartości wskaźnika rozkazu (IP) celem uzyskania 16-bitowego adresu efektywnego.

Rozkazy bezadresowe: 0 1 2 3 4 5 6 7

op ope

Rozkazy wejścia-wyjścia: 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15

op ope ioa

Adres portu

Rozkazy skoków warunkowych: 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15

op cnd dsp

Adres względny Rozkazy z adresem względnym: 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15

op m dsp

0 0 Adres względny Rozkazy z argumentem bezpośrednim: 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23

op m Argument

0 1 Rozkazy z adresem bezpośrednim: 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23

op m Adres argumentu

1 0 Rozkazy z adresem pośrednim: 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23

op m Adres adresu argumentu

1 1

Rys.8.5. Formaty rozkazów. Oznaczenia: op - kod rozkazu, ope - rozszerzenie kodu operacji, ioa – adres portu we/wy, m – sposób adresacji, cnd – kod warunku, dsp – adres względny.

Lista rozkazów

Lista rozkazów została skomponowana przy założeniu możliwie maksymalnego ograniczenia liczby rozkazów adresowych, wynikającego z przyjęcia 4-bitowego kodu operacyjnego. W konsekwencji, rozkazy takie, w wersji z adresacją względną, mogą być kodowane w jednym słowie maszynowym przy zachowaniu rozsądnej wielkości przesunięcia argumentu względem aktualnego miejsca rozkazu (displacement).

Poniżej opisano wszystkie rozkazy pogrupowane według ich funkcji. Dla każdego rozkazu podano jego nazwę, mnemonik i składnię w języku asemblera a następnie symboliczny zapis wykonywanej operacji i ewentualny komentarz.


Rozkazy przesłań

Ładowanie akumulatora (Load). LD src

AC src Argument src może być bezpośredni lub z pamięci.

Pamiętanie akumulatora (Store). ST dst

dst AC Argument dst musi być w pamięci.

Ładowanie wskaźnika stosu z akumulatora (Load SP). LSPA

SP AC

Zapamiętanie akumulatora na stosie (Push AC). PUSHA

Zmniejszenie SP; stos AC Stos narasta w kierunku adresów malejących.

Ładowanie akumulatora ze stosu (Pop AC). POPA

AC stos; zwiększenie SP. Stos narasta w kierunku adresów malejących.

Zapamiętanie znaczników (słowa stanu) na stosie (Push PS). PUPS

Zmniejszenie SP; stos PS Stos narasta w kierunku adresów malejących.

Ładowanie znaczników (słowa stanu) ze stosu (Pop PS). POPS

PS stos; zwiększenie SP.+ Stos narasta w kierunku adresów malejących.

Rozkazy wejścia-wyjścia

Wprowadzenie zawartości portu do akumulatora (Input). IN port

AC<8:15> port Adres portu może być 8 bitowy. Początkowe bity akumulatora <0:7> pozostają niezmienione.

Przesłanie akumulatora do portu (Output). OUT port

port AC<0:7> Adres portu może być 8 bitowy


Dodawanie w kodzie uzupełnieniowym (Add). ADD src

AC AC + src Znacznik C przyjmuje wartość przeniesienia z bitu znakowego.

Dodawanie z przeniesieniem (Add carry). ADC

AC AC + src + C Znacznik C przyjmuje wartość przeniesienia z bitu znakowego.

Odejmowanie w kodzie uzupełnieniowym (Subtract). SUB src

AC AC - src Znacznik C przyjmuje wartość pożyczki do bitu znakowego.


Odejmowanie z pożyczką (Subtract borrow). SBB

AC AC - src - C Znacznik C przyjmuje wartość pożyczki do bitu znakowego.

Zmiana znaku liczby w akumulatorze (Negate). NEG

AC 0 - AC Znacznik S przyjmuje wartość bitu znakowego wyniku.

Porównanie (Compare). CMP src AC - src Ustawiane są znaczniki C,S, Z, V. Wynik odejmowania nie jest zapamiętywany.

Rozkazy logiczne

Iloczyn logiczny (And). AND src

AC AC & src Znacznik Z jest ustawiany, gdy AC=0, w przeciwnym przypadku Z jest zerowany. Działanie dotyczy odpowiadających sobie bitów argumentów.

Uzupełnienie logiczne zawartości akumulatora (Complement accumulator). CPA

AC AC Działanie dotyczy każdego bitu akumulatora.


Przesunięcie akumulatora w prawo o jedną pozycję (Shift right). SHR

0 AC C

Znacznik C przyjmuje wartość bitu AC<15>, na pozycję AC<0> wpisywane jest 0.

Przesunięcie arytmetyczne akumulatora w prawo o jedną pozycję (Shift right arithmetically). ASHR

AC C

Znacznik C przyjmuje wartość bitu AC<15>, na pozycji AC<0> powielany jest bit znakowy.

Przesunięcie akumulatora w lewo jedną pozycję (Shift left). SHL

C AC 0

Znacznik C przyjmuje wartość bitu AC<0>, na pozycję AC<15> wpisywane jest 0.

Cykliczne przesunięcie akumulatora w prawo o jedną pozycję (Rotate right). ROR

AC C


Cykliczne przesunięcie akumulatora w lewo o jedną pozycję (Rotate left). ROL

C AC

Zamiana bajtów w akumulatorze (Swap bytes). SWAP

AC<0:7> AC<8:15>

Rozkazy manipulujące znacznikami

Zerowanie znacznika C (Clear carry). CC

C 0

Ustawianie znacznika C (Set carry).. SC

C 1

Uzupełnienie logiczne znacznika C (Complement carry). CPC

C C

Zerowanie znacznika IE; maskowanie przerwań (Clear Interrupt Enable bit) CI

IE 0

Ustawianie znacznika IE; otwarcie przerwań (Set Interrupt Enable bit) SI

IE 1

Rozkazy sterujące

Skok bezwarunkowy. (Jump) JMP adr

IP adr Argument jest adresem.

Skok warunkowy gdy C=1 (Branch if carry) BC adr

Jeżeli C=1, to IP IP + dsp Argument jest adresem, przy czym |adr – IP| < 512.

Skok warunkowy gdy Z=1 (Branch if zero) BZ adr

Jeżeli Z=1, to IP IP + dsp Argument jest adresem, przy czym |adr – IP| < 512.

Skok warunkowy gdy S=1 (Branch if minus) BM adr

Jeżeli S=1, to IP IP + dsp Argument jest adresem, przy czym |adr – IP| < 512.

Skok warunkowy gdy V=1 (Branch if overflow) BV adr

Jeżeli V=1, to IP IP + dsp Argument jest adresem, przy czym |adr – IP| < 512


Przeskok wyliczany (Count). CNT dst

dst dst + 1, następnie jeżeli dst=0, to IP IP + 3 Argument nie może być bezpośredni.

Wywołanie podprogramu (Call). CALL adr

Zmniejszenie SP, stos IP, IP adr Argument jest adresem.

Powrót z podprogramu (Return). RET

IP stos, zwiększenie SP

Powrót z przerwania (Return from interrupt). RETI

IP, PS stos, zwiększenie SP

Inne

Brak działania (No operation) NOP Nie wykonują się żadne przesłania i inne zmiany stanu.

Zatrzymanie pracy procesora (Halt) HALT Przerwania nie są przyjmowane, ponowne uruchomienie wymaga interwencji operatora.

Oczekiwanie na przerwanie (Wait) WAIT Nie wykonują się żadne przesłania i inne zmiany stanu, są przyjmowane przerwania.

Przerwania

Procesor przyjmuje sygnały zgłoszeń przerwań na wejściu int. Jeżeli przerwania są otwarte (bit IE w PS jest ustawiony na 1), to następuje zapamiętanie na stosie słowa stanu (PS) i licznika rozkazów

(IP), zablokowanie przerwań (IE 0), a następnie przejście do programu spod adresu

bezwzględnego 0003h (IP 3).

Otwieranie i maskowanie przerwań może być programowe - za pomocą rozkazów SI i CI.

Identyfikacja przerwań zewnętrznych następuje metodą programowego przepytywania (zob. przykłady programów).


Formalny opis architektury Ghibli

Cały opis sformalizowany, poza komentarzami, wyróżniono innym krojem czcionki. Komentarze są zwięzłym powtórzeniem opisu słownego i dla symulacji działania komputera nie są konieczne.

Elementy pamięciowe:

M[0:65535]<0:7> pamięć główna (64K bajty)

AC<0:15> akumulator (accumulator)

IP<0:15> wskaźnik rozkazu(instruction pointer)

SP<0:15> wskaźnik stosu (stack pointer)

PS<0:15> słowo stanu (progarm status word)

C := PS<0> znacznik przeniesienia arytmetycznego

S := PS<1> znacznik znaku arytmetycznego

Z := PS<2> znacznik zera

V := PS<3> znacznik nadmiaru

IE := PS<7> znacznik otwarcia przerwań

IPT[0:255]<0:7> porty wejściowe

OPT[0:255]<0:7> porty wyjściowe

RUN znacznik stanu maszyny

WAIT znacznik oczekiwania na przerwanie

int sygnał żądania przerwania (interrupt)

ss sygnał startu i zatrzymania

Adres efektywny: e<0:15>

Rozkaz: i<0:15>

op := i<0:3> kod operacyjny

ope := i<4:7> rozszerzenie kodu operacyjnego

m := i<4:5> sposób adresacji

cnd := i<4:5> badany warunek

ioa := i<8:15> adres portu we-wy (0 ... 255)

dsp := i<6:15> przesuniecie (displacement) (-512 ... +511)

Inicjalizacja:

ss => RUN not RUN;

PS 0; IP 0; SP 0; AC 0; WAIT 0

Cykl rozkazowy: RUN => (int and IE) => interrupt; next

not WAIT => (fetch; next address; next execution)

interrupt := WAIT 0; next SP SP–2; next

M[SP] PS; next SP SP–2; next M[SP] IP;

next IP 3,

fetch := i M[IP]; next IP IP+1,

address := (op = 2) => IP IP+1;

(op = 3) => IP IP+1; next e IP+dsp;

(3 < op < 15) => (

(m=0)=> IP IP+1; next e IP+dsp;

(m=1)=> e IP; next IP IP+2;

(m=2)=> e M[IP]; next IP IP+2;

(m=3)=> e M[M[IP]]; nextIP IP+2)


execution := (

(op=0) =>(

NOP (:=(ope=1)) => ;

HALT (:=(ope=2)) => RUN 0;

WAIT (:=(ope=3)) => WAIT 1;

RET (:=(ope=4)) => IP M[SP]; next SP SP+2;

RETI (:=(ope=5)) => IP M[SP]; next SP SP+2;

next PS M[SP]; next SP SP+2;

SI (:=(ope=6)) => IE 1;

CI (:=(ope=7)) => IE 0;

SC (:=(ope=8)) => C 1;

CC (:=(ope=9)) => C 0;

CPC (:=(ope=10)) => C not C;

NEG (:=(ope=11)) => AC neg AC; next S AC<0>;

LSPA (:=(ope=12)) => SP AC)

(op=1) =>(

CPA (:=(ope=3)) => AC not AC;

ROR (:=(ope=4)) => AC ror AC; next C AC<0>;

ROL (:=(ope=5)) => AC rol AC; next C AC<15>;

SHR (:=(ope=6)) => AC^C shr AC^C; ,

SHL (:=(ope=7)) => CÂC shl CÂC;

ASHR (:=(ope=8)) => AC^C shra AC^C;

SWAP (:=(ope=9)) => AC<0:7> AC<8:15>;

PUSHA (:=(ope=10)) => SP SP-2; next M[SP] AC;

POPA (:=(ope=11)) => AC M[SP]; next SP SP+2;

PUPS (:=(ope=12)) => SP SP-2; next M[SP] PS;

POPS (:=(ope=13)) => PS M[SP]; next SP SP+2)

(op=2) =>(

IN (:=(ope=1)) => AC<8:15> IPT[ioa])

OUT (:=(ope=2)) => OPT[ioa] AC<0:7>)

(op=3) =>(

BC (:=(cnd=0)) => (C => IP e);

BZ (:=(cnd=1)) => (Z => IP e);

BM (:=(cnd=2)) => (S => IP e);

BV (:=(cnd=3)) => (V => IP e))

LD (:=(op=4)) => AC M[e];

ST (:=(op=5)) => M[e] AC;

ADC (:=(op=6) => CÂC AC + M[e] + C;

ADD (:=(op=7)) => CÂC AC + M[e];

SUB (:=(op=8)) => CÂC AC - M[e];

CMP (:=(op=9)) => Z ((AC - M[e])=0);

SBB (:=(op=10)) => CÂC AC - M[e] - C;

AND (:=(op=11)) => AC AC and M[e]; next Z (AC=0);

JMP (:=(op=12)) => IP e;

CALL (:=(op=13)) => (SP SP-2; next M[SP] IP; next

IP e);

CNT (:=(op=14)) => M[e]<0:15> M[e]<0:15>+1; next,

(M[e]=0) => IP IP+3)


Język asemblera

Przedstawiony asembler Ghibass jest tzw. asemblerem prostym, co oznacza, że nie ma w nim możliwości stosowania makrodefinicji i poleceń warunkowych.

Przyjęty styl, wyróżniający tekstowo poszczególne elementy języka, wzorowano na asemblerach mini- i mikrokomputerów zachowując najczęściej występujące w nich mnemoniki. Wprowadzone ograniczenia (np. krótkie nazwy) ułatwiają ewentualną implementację programu asemblującego (np. asemblera skrośnego) oraz czynią przejrzystym zapis przykładowych programów.

Sposoby adresacji

Są cztery sposoby adresacji argumentów w rozkazie. W języku asemblera wyróżnia się tylko trzy z nich: adresacja natychmiastowa (z argumentem bezpośrednim), adresacja bezpośrednia i adresacja pośrednia.

Tab.8.1. Sposoby adresacji argumentów

Składnia asemblera

Nazwa Kodowanie (pole m)

Adres efektywny (e)

Długość rozkazu

w bajtach

A

Bezpośrednia względna (bliska)

00

IP+dsp

2

#D

Natychmiastowa (argument bezpośredni)

01

IP

3

A

Bezpośrednia bezwzględna (daleka)

10

M[IP]

3

@A

Pośrednia

11

M[M[IP]]

3

W przypadku adresacji bezpośredniej, w czasie kompilacji program asemblujący wybiera adresację bliską lub daleką - zależnie od odległości adresu od rozkazu, w którym występuje; jeżeli ta odległość daje się zakodować w 10-bitowym polu dsp, wybierana jest adresacja bliska. Odległość dsp wynosi od -512 do +511 bajtów i odnosi się do adresu rozkazu następującego za rozkazem zawierającym adresowany argument.

Adresację bezwzględną (m=2) można wymusić stosując prefiks FAR.

W podanej tablicy A oznacza nazwę lub wartość adresu, D - nazwę lub wartość stałej, N – numer (adres) portu we-wy z zakresu (0, 255), L – adres skoku warunkowego spełniający warunek |L-IP| < 512.


Rozkazy

Lista rozkazów zawiera 40 rozkazów uszeregowanych w Tab.2 wg kodów operacyjnych. Funkcje poszczególnych rozkazów są dokładnie zdefiniowanie w zapisie architektury, gdzie dla większej przejrzystości użyto mnemoników asemblera. W całym opisie elementy języka są wyróżnione innym krojem czcionki.

Tab. 8.2. Lista rozkazów

Kod (hex)

Mnemonik Modyfikowane znaczniki

Dopuszczalne argumenty

Funkcja

01 NOP Brak działania

02 HALT Zatrzymanie pracy procesora

03 WAIT Oczekiwanie na przerwanie

04 RET Powrót z podprogramu

05 RETI C,S,Z,V,IE Powrót z przerwania

06 SI IE Ustawienie IE

07 CI IE Zerowanie IE

08 SC C Ustawienie C

09 CC C Zerowanie C

0A CPC C Uzupełnienie C

0B NEG S,V Zmiana znaku akumulatora

0C LSPA Ładowanie SP

13 CPA S,Z Uzupełnienie logiczne AC

14 ROR C,S,Z Rotacja AC w prawo

15 ROL C,S,Z Rotacja AC w lewo

16 SHR C,S,Z Przesunięcie AC w prawo

17 SHL C,S,Z Przesunięcie AC w lewo

18 ASHR C,S,Z Przes. arytmetyczne w prawo

19 SWAP Zamiana bajtów w AC

1A PUSHA Przesłanie AC na stos

1B POPA Pobranie AC ze stosu

1C PUPS Przesłanie PS na stos

1D POPS C,S,Z,V,IE Pobranie PS ze stosu

21 IN N Pobranie bajta z portu do AC

22 OUT N Wysłanie bajta z AC do portu

3^00..* BC L Skok gdy C=1

3^01..* BZ L Skok gdy Z=1

3^10..* BM L Skok gdy S=1

3^11..* BV L Skok gdy V=1

4 LD A @A #D Ładowanie AC

5 ST A @A Pamiętanie AC

6 ADC C,S,Z,V A @A #D Dodawanie przeniesienia

7 ADD C,S,Z,V A @A #D Dodawanie

8 SUB C,S,Z,V A @A #D Odejmowanie

9 CMP C,S,Z,V A @A #D Porównanie

A SBB C,S,Z,V A @A #D Odejmowanie pożyczki

B AND S,Z A @A #D Iloczyn logiczny

C JMP A @A Skok bezwarunkowy

D CALL A @A Wywołanie podprogramu

E CNT A @A Skok wyliczany**

* Druga tetrada kodu zawiera 2-bitowe pole cnd i 2 początkowe bity pola disp.

** Asembler wyrównuje rozkaz następujący za CNT do 3 bajtów (dodając przed nim NOP)


Dyrektywy

Jest pięć dyrektyw i jeden prefiks, które sterują przebiegiem asemblacji

Dyrektywa "Koniec programu" (END of program)

.END [etykieta]

Tekst następujący za dyrektywą END nie jest przetwarzany przez asembler. Opcjonalna etykieta wskazuje pierwszy rozkaz, który ma być wykonany po uruchomieniu programu.

Dyrektywa "Definicja bajtów" (Define Byte)

[etykieta] .DB lista stałych

Stałe wymienione w polu argumentów są umieszczane w kolejnych bajtach pamięci zaczynając od adresu wskazywanego przez licznik lokacji.

Przykład:

Po dyrektywie

ARGM .DB 15,15h,255,’b’,’7’

asembler inicjalizuje w pamięci pięć bajtów o adresach ARGM .. ARGM+4

ARGM : 0F

ARGM+1 : 15

ARGM+2 : FF

ARGM+3 : 62

ARGM+4 : 37

Dyrektywa "Definicja słów" (Define Word)

[etykieta] .DW lista stałych

Stałe wymienione w polu argumentów są umieszczane w kolejnych słowach pamięci zaczynając od adresu wskazywanego przez licznik lokacji.

Przykład:

Po dyrektywie

PARM .DW 15,’ab’,258,4A27h

asembler inicjalizuje w pamięci cztery słowa o adresach PARM .. PARM+6

PARM : 000F

PARM+2 : 6162

PARM+4 : 0102

PARM+6 : 4A27

Dyrektywa "Rezerwacja bloku" (reserve a BLocK) rezerwuje n kolejnych bajtów pamięci.

[etykieta] .BLK stała

Licznik lokacji jest zwiększany o wartość stałej n. Poprzednia zawartość zarezerwowanej pamięci nie jest zmieniana (w szczególności nie jest zerowana).

Dyrektywa "Początek sekcji" (define the ORiGin of the section)

.ORG stała

Wartość stałej n jest wprowadzana do licznika lokacji; następny rozkaz lub dana będzie umieszczona pod adresem n.

Dyrektywa "Równe" (EQUal).

nazwa .EQU stała

Przypisuje nazwie wartość stałej n zapisanej na dwóch bajtach. Nazwa może być używana w dalszej części programu zamiast stałej n.


Prefiks "Adresacja bezwzględna" (FAR)

.FAR

W adresacji bezpośredniej domyślnym trybem jest adresacja względna ("bliska", m=0), która pozwala kodować rozkaz w jednym słowie maszynowym. Użycie prefiksu FAR wymusza adresację bezwzględną ("daleką", m=2) z pełnym adresem 16-bitowym; rozkaz kodowany jest wówczas w trzech kolejnych bajtach.

Składnia

Podstawowy format linii programu jest następujący (nazwy pól opcjonalnych umieszczono w nawiasach prostokątnych):

[etykieta] mnemonik [argumenty] [;komentarz]

Poszczególne pola linii programu muszą być oddzielone co najmniej jedną spacją.

Nazwy i etykiety są łańcuchami zawierającymi od 1 do 6 znaków i muszą zaczynać się od litery. Nazwa jest symboliczną reprezentacją danej (stałej); etykieta jest symboliczną reprezentacją adresu. Jako nazwy i etykiety nie mogą być użyte mnemoniki rozkazów i dyrektyw.

Przykład 1:

ASHRIN .EQU 14H ;14h=20

..........

..........

ADD #ASHRIN ;AC = AC + 20

Przykład 2:

PARM .DW 20,135,...

..........

..........

ADD PARM ;AC = AC + 20

Numeryczne argumenty instrukcji i pseudoinstrukcji .DW, .BLK, .ORG i .EQU są liczbami dziesiętnymi lub szesnastkowymi. Liczby szesnastkowe muszą zaczynać się cyfrą dziesiętną i kończyć literą <h> lub <H>.

Zamiast argumentów numerycznych można używać poprzednio zdefiniowanych nazw.

Komentarz zaczyna się po średniku <;> i kończy znakiem nowej linii. Komentarz może zawierać dowolne znaki; jego zawartość nie jest przeglądana ani interpretowana przez asembler.

Przykłady programów

Mnożenie przez wielokrotne dodawanie

Przedstawiono przykład fragmentu programu mnożącego liczby (w kodzie U2) metodą wielokrotnego dodawania mnożnej. Dodawanie jest wykonywane przez podprogram powtarzający obliczenia tyle razy ile wynosi wartość mnożnika.


;Program mnozenia metoda wielokrotnego dodawania

;mnoznej

A .EQU 13 ;mnozna

K

.EQU

25 ;mnoznik

.ORG 3200h ;poczatek programu

LICZ .BLK 2 ;miejsce na licznik powtorzen

ILO .BLK 2 ;miejsce na wynik

MNA .BLK 2 ;miejsce na mnozna

LD #K ;wpisanie mnoznika do akumulatora

NEG ; uzupelnienie

ST LICZ ; i wpisanie do licznika

LD #A ;wpisanie mnoznej do akumulatora

ST MNA ;i do mnoznej

CALL MNO ;wywolanie programu mnozenia

CALL DRUK ;wywolanie programu drukowania

;Podprogram mnozenia

.ORG 4300h

MNO: LD #0 ;zerowanie akumulatora

POWT: ADD MNA ;dodanie mnoznej

CNT LICZ ;aktualizacja licznika, koniec?

JMP POWT ;nie, powtorzenie

ST ILO ;koniec, zapamietanie wyniku

RET ;wyjscie z podprogramu

.END ;koniec tekstu programu

Wydruk tego programu po asemblacji zawiera adresy pamięci w postaci szesnastkowej (pierwsza kolumna), zawartość komórek pamięci (druga kolumna) i powtórzenie treści programu (cztery następne kolumny):

;Program mnozenia metoda wielokrotnego dodawania

;mnoznej

00 0D A .EQU 13 ;mnozna

00 19 K .EQU 25 ;mnoznik

32 00 .ORG 3200h ;poczatek programu

3200 **** LICZ .BLK 2 ;miejsce na licznik powtorzen

3202 **** ILO .BLK 2 ;miejsce na wynik

3204 **** MNA .BLK 2 ;miejsce na mnozna

3206 44 00 19 LD #K ;wpisanie mnoznika do akumulatora

3209 0B NEG ; uzupelnienie

320A 53 F3 ST LICZ ; i wpisanie do licznika

320D 44 00 0D LD #A ;wpisanie mnoznej do akumulatora

3210 53 F2 ST MNA ;i do mnoznej

3212 D8 43 00 CALL MNO ;wywolanie programu mnozenia

3215 D. .. CALL DRUK ;wywolanie programu drukowania

;Podprogram mnozenia

43 00 .ORG 4300h

4300 44 00 00 MNO LD #0 ;zerowanie akumulatora

4303 78 32 04 POWT ADD MNA ;dodanie mnoznej

4306 E8 32 00 CNT LICZ ;aktualizacja licznika, koniec?

4309 01

430A C3 F7 JMP POWT ;nie, powtorzenie

430C 58 32 02 ST ILO ;koniec, zapamietanie wyniku

430F 04 RET ;wyjscie z podprogramu

.END ;koniec tekstu programu


Wartość pola dsp w rozkazie jest obliczana względem następnego rozkazu; np. w rozkazie "JMP POWT"

dsp = POWT - IP = 4303 – 430C = FFF7,

co po obcięciu do 10 bitów daje wartość 3F8 w kodzie uzupełnieniowym. Po zestawieniu 4-bitowego kodu operacji JMP (1100), 2-bitowego pola m (00) i 10-bitowego dsp (11 1111 0111) kod szesnastkowy całego rozkazu jest C3F7.

Przed rozkazem „JMP POWT” asembler wstawia kod rozkazu NOP (01h) dla wyrównania do 3 bajtów zasięgu przeskoku rozkazu CNT.

W rozkazach "ADD MNA", "CNT LICZ" i "ST ILO" musi być użyta adresacja bezwzględna, (m=10) gdyż odległość do argumentów przekracza 512 bajtów.

Wartość adresów symbolicznych określonych przez etykiety, przy podanych wartościach parametrów dyrektyw .ORG jest następująca:

ILO=3202, LICZ=3200, MNA=3204, MNO=4300, POWT=4303.

Kopiowanie bloku bajtów w pamięci.

Blok o długości k bajtów umieszczony pod adresem TUTAJ jest kopiowany pod adres TAM.

Przed wywołaniem podprogramu trzeba nadać wartość stałej ILE:

ILE .EQU k

i zarezerwować miejsca na zmienne pomocnicze:

WSK1 .BLK 2

WSK2 .BLK 2

LIPO .BLK 2

;Podprogram kopiowania bloku o dlugosci ILE bajtów z TUTAJ do

;TAM, korzysta z zarezerwowanych miejsc WSK1, WSK2 i LIPO

;Wywolanie: CALL KOPIA

;

KOPIA: LD #TUTAJ ;adres 1. bloku

ST WSK1 ; do wskaznika 1.

LD #TAM ;adres 2. bloku

ST WSK2 ; do wskaznika 2.

LD #ILE ;dlugosc bloku (k)

NEG ; -k

ST LIPO ; do licznika powtorzen

PETLA: LD @WSK1 ;bajt z bloku 1. do AC

ST @WSK2 ; i do bloku 2.

CNT WSK1 ;aktualizacja wsk.1

CNT WSK2 ;aktualizacja wsk.2

CNT LIPO ;czy koniec kopiowania?

JMP PETLA ;nie - powtorz

RET ;tak - wyjscie z podprogramu


Identyfikacja zgłoszonego przerwania (polling).

Program identyfikuje jedno z 3 możliwych źródeł przerwania (A, B lub C) i powołuje odpowiedni program obsługi (PROB_A, PROB_B lub PROB_C).

Zgłoszenie przerwania przez każde urządzeniu powoduje w jego rejestrze stanu ustawienie bitu <7> na „1”.

Odpowiednie rejestry stanu mają adresy: PORT_A, PORT_B, PORT_C.

INTID: IN PORT_A ;pobranie slowa stanu urzadzenia A

AND #0001H ;czy bylo zgloszenie?

BZ DRUGI ; nie - testuj nastepne

CALL PROB_A ; tak - przejscie do obslugi A

DRUGI: IN PORT_B ;pobranie slowa stanu urzadzenia B


BZ TRZECI ; nie - testuj nastepne

CALL PROB_B ; tak - przejscie do obslugi B

TRZECI: IN PORT_C ;pobranie slowa stanu urzadzenia C


BZ KONIEC ; nie - koniec sprawdzania

CALL PROB_C ; tak - przejscie do obslugi C

KONIEC: SI ;otwarcie przerwań

RETI ;powrót do przerwanego programu

Program ten może być wywoływany spod adresu 0003 rozkazem JMP INTID. Po zakończeniu obsługi wszystkich zgłoszeń, rozkaz RETI powoduje powrót do przerwanego programu.

Przyjęto, że programy obsługi nie otwierają przerwań (zamaskowanych automatycznie po przyjęciu zgłoszenia).

Transmisja jednego znaku.

Założenia:

program jest powoływany jako program obsługi przerwania (p.4.5.3) z urządzenia X, będącego nadajnikiem-odbiornikiem,

urządzenie dysponuje trzema rejestrami 8-bitowymi:

PORT_X - rejestr stanu,

DT - bufor nadajnika,

DR - bufor odbiornika,

w rejestrze stanu (PORT_X) zdefiniowano następujące znaczniki:

0 1 2 3 4 5 6 7

bit <7> = 1 - zgłoszenie przerwania

bit <6> = 1 - gotowość pobrania znaku do bufora DTX celem wysłania (nadajnik)

bit <5> = 1 - gotowość przekazania z bufora DRX odebranego znaku (odbiornik)

odbierane znaki są zapisywane w pamięci pod adres wskazywany we wskaźniku WSOD,

wysyłane znaki są pobierane z pamięci spod adresu wskazywanego przez WSNA,

zakończenie transmisji następuje po wykryciu znaku <NUL> (00h) i wówczas program wpisuje kod 01 (nadajnik) lub 02 (odbiornik) do komórki STATRS.


PROB_X: IN PORT_X ;rejestr stanu do AC

ROR

ROR

ROR

BC ODBIOR ;jest gotowość odbiornika

JMP CZYNAD ;odbiornik nie zgłaszał gotowości

;

;Odbior

;

jednego

znaku

ODBIOR: IN DRX

AND #OFH ;czy <NUL>?

BZ KONCOD ; tak, koniec odbioru

CNT WSOD ; nie, aktualizacja wskaźnika

SWAP ;przestawienie bajtów w akumulatorze

ST @WSOD ;zapisanie bajta (i zerowanie następnego)

CZYNAD: IN PORT_X ;rejestr stanu do AC

ROR

ROR

BC NADAWA ;jest gotowość nadajnika

WYJ:

;

;Wysłanie

;

RET

jednego

znaku

;nadajnik też nie zgłasza gotowości, wyjscie

NADAWA: LD @WSNA ;ładowanie dwóch bajtów do AC

AND #0F0H ;wycięcie drugiego i sprawdzenie czy <NUL>

BZ KONCNA ; tak, koniec nadawania

OUT DTX ; nie, wysłanie do urządzenia

CNT WSNA ;aktualizacja wskaźnika

JMP WYJ ;wyjście

;

;Koniec transmisji

;

KONCOD: LD #2 ;kod końca odbioru

KON: ST STATRS

JMP WYJ

KONCNA: LD #1 ;kod końca nadawania

JMP KON

Struktura

W strukturze komputera wyróżniono cztery części: pamięć główną , centralne sterowanie, arytmometr i zespół portów wejścia-wyjścia komunikujących się przez wspólną szynę 16-bitową.

Wszystkie rejestry są 16-bitowe z wyjątkiem 8-bitowych portów wejścia-wyjścia. Na schematach stuktury rejestrowej komputera zaznaczono sygnały mikrooperacji sterujących przesłaniami i funkcjami poszczególnych bloków komputera:

r - odczyt z pamięci,

w - zapis do pamięci,

fR - przesłanie z rejestru R na szynę,

tR - przesłanie z szyny do rejestru R,

mA - przesłanie z AC do ALU,

add, and, inc, not, rol, ror, shl, shr, shra, sub - mikrooperacje ALU,

sC, cC, sIE, cIE – ustawianie i zerowanie znaczników C i IE,

iIP - inkrementacja IP (+1),

iSP - inkrementacja SP (+2),

dSP - dekrementacja SP (-2),


Pamięć

Centralne sterowanie

Start/stop Przerwanie

Szyna

Arytmometr

Porty wejścia i

wyjścia

Połączenia z

urządzeniami we-wy

Rys. 8.6. Ogólna struktura komputera Ghibli

Pamięć główna

Pamięć ma 65536 bajtów 8-bitowych, które mogą być zapisywane (mikrooperacja r) lub odczytywane (w) parami poprzez 16-bitowy rejestr danych MB. Aktualny adres zapisu/odczytu musi być umieszczony w rejestrze adresowym AR. Rejestr adresu efektywnego EAR spełnia rolę pomocniczą w złożonych trybach adresacji.

MB fMB

r

tMB

w fEAR EAR

M

AR tEAR

tAR

Szyna

Rys.8.7. Struktura rejestrowa pamięci głównej.

Centralne sterowanie

Centralne sterowanie generuje wszystkie sygnały wykonawcze mikrooperacji potrzebne do realizacji cyklu rozkazowego.

Rozkaz pobrany z pamięci do rejestru rozkazów IR jest dekodowany w bloku CU. Blok ten zawiera również zegar taktujący pracę całego procesora oraz układy obsługi przerwań (int) i sygnału startu/zatrzymania pracy (ss). Licznik rozkazów IP wskazuje zawsze adres następnego rozkazu do wykonania; po pobraniu rozkazu zawartość IP jest zwiększana o 1 mikrooperacją iIP.

Blok adresatora AA służy do obliczania adresu efektywnego w trybie adresacji względnej; na wyjściu AA sterowanym mikrooperacją fAA pojawia się zawsze suma IP + disp, gdzie disp jest zawartością 10 mniej znaczących bitów rozkazu traktowanych jako liczba z zakresu -512..+511.

Rejestr SP zawiera adres słowa znajdującego się aktualnie na wierzchu stosu; rejestr ten może być inkrementowany (mikrooperacja iSP) bądź dekrementowany (dSP) celem zapełniania stosu lub jego opróżniania. Zmiana SP jest zawsze o 2 , ponieważ na stosie mogą być przechowywane tylko 2-bajtowe słowa.


iIP fIP

IP tIP

fSP iSP

AA fAA dSP

tSP SP

tIR

IR

Sygnały

sterujące

mikro- CU

operacji

ss int Szyna

Rys.8.8. Struktura rejestrowa centralnego sterowania.

Arytmometr

Arytmometr wykonuje wszystkie operacje arytmetyczne i logiczne oraz operacje przesunięć wymagane przez listę rozkazów. W operacjach dwuargumentowych jeden argument jest pobierany z akumulatora AC a drugi argument wprost z szyny. Wynik działania, wybranego przez mikrooperacje sterujące blokiem ALU, są zapamiętywane w buforze AB skąd mogą być podane na szynę (mikrooperacja fAB).

AC fAC

add

mA tAC

... ALU

shra tALU

AB

C S Z V fAB

Szyna

Rys.8.9. Struktura rejestrowa arytmometru.


Porty wejściowe i wyjściowe

Porty wejściowe IPT i wyjściowe OPT są 8-bitowe. Aktywny sygnał fIPT[k] powoduje przekazanie zawartości portu k na linie <8:15> szyny. Sygnał tOPT[k] wpisuje dane z linii <0:7> szyny do portu wyjściowego o numerze k.

OPT[0]

tOPT[0]

(Porty

wyjściowe)

OPT[255]

tOPT[255]

fIPT[0] IPT[0]

(Porty

wejściowe)

fIPT[255] IPT[255]

Szyna

Rys.8.10. Struktura portów wejścia i wyjścia.

Sygnały fIPT i tOPT są generowane w cyklu wykonania rozkazów IN i OUT przy czym adres portu jest określony w polu adresowym tych rozkazów.


Dorośli są zakochani w cyfrach.

Antoine de Saint-Exupéry

Język opisu architektury

Podstawy

Przedstawiony język jest modyfikacją notacji ISP (Instruction Set Processor) wprowadzonej w książce G.C.Bell'a i A.Newell'a "Computer Structures" i często stosowanej w różnych wersjach publikacyjnych. Formalizm ten nadaje się do opisu architektury na poziomie listy rozkazów (IS - Instruction-Set level) a także, choć jest mniej wygodny, do opisu struktury na poziomie rejestrowym (RTL - register-transfer level).

Notacja

W notacji ISP (Instruction-Set Processor) można podać model procesora lub innego bloku funkcjonalnego opisujący zachowanie się tego bloku (jego architekturę) na poziomie elementów i sygnałów dwustanowych. W przyjętej tutaj notacji wprowadzono pewne uściślenia pochodzące z języka ISPS będącego dojrzałym następcą ISP, zachowując jednak z oryginału specyficznie sugestywne oznaczenia operatorów lub wprowadzając własne - dla zwiększenia przejrzystości opisu działań.

Model bloku funkcjonalnego opisany formalnie zawiera dwie części:

deklaracje zmiennych,

zapis możliwych zmian stanu

i w zasadzie nie wymaga komentarza dla zrozumienia jego działania (zachowania się) w każdej sytuacji określonej przez dowolny stan jego elementów.

Zmiany stanu są wynikiem sekwencji działań polegających na nadaniu nowych wartości zmiennym, co formalnie zapisuje proces przesłania informacji między elementami pamięciowymi. Działania te są zawsze zapisywane jako działania warunkowe, wg formuły

p => a,

gdzie p jest zmienną binarną (przyjmującą wartości 0 lub 1) lub relacją (przyjmującą wartości "fałsz" lub "prawda") zaś a oznacza sekwencję akcji realizowanych gdy p = 1 lub p = "prawda".

Deklaracje i definicje

Deklaracje zmiennych dotyczą wszystkich elementów pamięciowych procesora (np. rejestrów programowych, znaczników stanu, pamięci operacyjnej) oraz innych zmiennych przydatnych do opisu zachowania się danej struktury nawet jeżeli nie mają one swojej implementacji układowej (np. struktura słowa rozkazowego) lub ta implementacja nie jest istotna dla definicji architektury.

Zmienne traktowane są jako łańcuchy binarne, dla których w deklaracji podaje się nazwę i format, t.j. liczbę i numerację (nazwy) bitów w łańcuchu. Jest to szczególnie wygodne przy deklarowaniu rejestrów, np. zmienna zadeklarowana jako

Brr<0:7>


może reprezentować zawartość 8-bitowego rejestru Brr, w którym bity są numerowane kolejno od zera poczynając od bitu bardziej znaczącego. Podobnie rejestr FLG złożony z 4 bitów nazwanych Ov, Cr, Z i Sgn będzie zadeklarowany jako

FLG<Ov,Cr,Z,Sgn>.

Dla uproszczenia opisu można definiować zmienne pomocnicze, będące fragmentem lub konkatenacją zmiennych zadeklarowanych wcześniej. Na przykład, jeżeli cztery bardziej znaczące bity zmiennej Brr mają być traktowane jako zmienna Koop a dwa najmniej znaczące bity Brr jako zmienna mik, to odpowiednie definicje będą następujące:

Koop<0:3> := Brr<0:3>

mik<0:1> := Brr<6:7>

Definicje warunkowe, które można też przedstawić jako formalne podstawienia, zapisuje się z użyciem operatora =>, np. definicja

Krk<0:1> := ((op gtr #3) => A;

(op eql #3) => B;

(op lss #3) => C)

nadaje nazwę Krk różnym zmiennym: A, B lub C - zależnie od wartości zmiennej op (odpowiednio dla op>3, op=3 i op<3).

Dopuszcza się definicje skrótowe dotyczące zmiennych binarnych, w których obok nazwy definiowanej zmiennej podaje się warunek przyjęcia przez te zmienną wartości 1, np.

CCS (:= op = #15)

definiuje zmienną CCS równą 1, gdy zmienna op ma wartość 15 szesnastkowo.

Przy deklaracji tablic zmiennych stosuje się podwójną indeksację: w nawiasach prostokątnych deklarowany jest zakres zmienności indeksów elementów tablicy (lub ich nazwy) zaś w nawiasach kątowych, jak dla zmiennych prostych, numeracja (lub nazwy) kolejnych pozycji binarnych zmiennej. Np. pamięć nazwana MM i zawierająca 64 Kbajty adresowane od 0 do 65535, z numeracja bitów typu little-endian będzie zadeklarowana jako

MM[0:65535]<7:0>

Jeżeli w polu indeksowym występują zmienne, to są traktowane jako liczba całkowita bez znaku, np. zapis

MM[addr]<2>

określa bit nr 2 w bajcie umieszczonym w pamięci MM pod adresem równym wartości zmiennej addr.

Zmiana stanu

Zmiany stanu realizowane fizycznie przez przesłanie informacji między rejestrami, zapisuje sie jako nadanie nowej wartości zmiennym. Formuła

L R

oznacza nadanie zmiennej L, występującej po lewej stronie operatora , wartości R. W szczególności

A f(A)

zawiera po lewej stronie strzałki nową wartość, jaką przyjmuje A po wykonaniu operacji f, natomiast po prawej stronie strzałki - wartość A przed wykonaniem tej operacji. Jeżeli formaty zmiennych są jednakowe, to nie jest konieczne podawanie ich specyfikacji.

Wyrażenia oznaczające poszczególne akcje przesłań są oddzielane średnikami, chyba że istotna jest ich kolejność - wówczas stosowany jest dodatkowy separator next. Np. formuła

wtr => A B; next B B+1

oznacza "jeżeli wtr=1, to prześlij B do A i następnie zwiększ wartość B o 1".


Operacje

Operacje dwuargumentowe zapisywane są w notacji infiksowej z użyciem operatorów mających postać skrótów mnemonicznych (słów kluczowych) drukowanych czcionką pogrubioną. Dla niektórych działań dopuszcza się opcjonalnie stosowanie znaków powszechnie używanych w matematyce.

Przesłania

Operacje te przesyłają wartość argumentu źródłowego (występującego po prawej stronie operatora) do miejsca przeznaczenia (występującego po lewej stronie).

Operatory przesłań:

przesłanie logiczne; rozszerza argument źródłowy przez dopisanie zer na lewo od pozycji najbardziej znaczącej lub obcina argument źródłowy aby go dopasować do formatu miejsca przeznaczenia,

przesłanie arytmetyczne; rozszerza argument źródłowy przez powielenie pozycji najbardziej znaczącej (bitu znakowego) lub obcina argument źródłowy aby go dopasować do formatu miejsca przeznaczenia,

jednoczesne przesłanie (wymiana wartości).

Przykład:

Jeżeli A<3:0> = 1011, B<7:0> = 10101010 i C<3:0> = 1100, to po przesłaniu

B A zawartość B = 11111011, po przesłaniu

B A zawartość B = 00001011, a po przesłaniu

C A

A = 1100, C = 1011.

Relacje

Operacje te porównują arytmetycznie dwa argumenty. Wynik jest jednobitowy: 0 - gdy relacja nie jest spełniona, 1 - gdy relacja jest spełniona.

Operatory relacyjne:

eql = równe (equal)

lss < mniejsze (less)

leq mniejsze lub równe (less or equal)

neq nie równe (not equal)

geq większe lub równe (greater or equal)

gtr > większe (greater)

Przykład:

Jeżeli A = 0111 i B = 0011, to

A geq B = 1.

Operacje logiczne

Obydwa argumenty tych operacji są traktowane jako łańcuch zero-jedynkowy i muszą mieć tę samą długość. Operacje są wykonywane na odpowiadających sobie pozycjach obu argumentów.

Operatory logiczne:

and lub & iloczyn logiczny,

or V suma logiczna,

xor różnica symetryczna,


not uzupełnienie logiczne (operator unarny),

eqv równoważność.

Przykład:

Jeżeli A = 0111 i B = 0010, to

A xor B = 0101.

Operacje arytmetyczne

W każdej operacji arytmetycznej, z wyjątkiem inc i dec, argumenty są traktowane jako liczby dwójkowe w kodzie uzupełnieniowym (reprezentacja {tc}), chyba że zaznaczono inny sposób reprezentacji przez dopisanie w nawiasach klamrowych odpowiedniego modyfikatora.

Domyślnym typem argumentu w operacjach inkrementacji i dekrementacji są liczby całkowite bez znaku (reprezentacja {sm}).

Operatory arytmetyczne:

add lub + dodawanie,

sub - odejmowanie,

mul * mnożenie,

div / dzielenie,

mod reszta z dzielenia,

neg 0 - negacja (zmiana znaku argumentu; operator unarny),

inc + 1 inkrementacja (operator unarny),

dec - 1 dekrementacja (operator unarny)

Przykład:

Jeżeli A = 0101 i B = 1110, to

A add B = 0011.

Operacje łańcuchowe

Argumenty tych operacji są traktowane jako łańcuchy zero-jedynkowe.

Operatory łańcuchowe:

^ konkatenacja (dopisanie)

shra arytmetyczne przesunięcie w prawo

shla arytmetyczne przesunięcie w lewo

shr przesunięcie w prawo

shl przesunięcie w lewo

ror cykliczne przesunięcie w prawo

rol cykliczne przesunięcie w lewo

Przykład:

Jeżeli A = 0101 i B = 1110, to

A^B = 01011110

2 shr B = 0011

2 shra B =1111

ror B = 0111


Inne symbole

Oprócz wymienionych operatorów stosowane są symbole pomocnicze:

:= symbol definicji ,

; separator ogólny,

next separator akcji sekwencyjnych,

rep znacznik powtórzenia akcji,

=> operator warunkowy "jeżeli .. to " (jeżeli lewostronne wyrażenie jest równe 1 lub relacja jest spełniona, to następuje sekwencja akcji wymienionych po prawej stronie)

! początek komentarza,

\ separator synonimów,

Przykłady:

A lss B => C K; next K inc K ! jeżeli A<B, to przeslij K do C ! i następnie zwiększ K o 1

Op_code\op<0:5> ! nazwy Op_code i op można stosować zamiennie

Nawiasów okrągłych używa się dla jednoznaczności i przejrzystości zapisu.

Stałe

System liczenia

Domyślną bazą stałych liczbowych jest 10. Inne systemy liczenia są zaznaczane przez użycie prefiksu ', " lub #.

Cyfry, których wartość nie jest istotna są zastępowane znakiem zapytania.

Prefiks Baza Przykład

' 2 (bin) '01101

" 8 (oct) "2577

# 16 (hex) #F2CF

10 (dec) 23945

Reprezentacja liczb

Domyślną reprezentacją jest uzupełnienie dwójkowe (2's complement). W przypadku stosowania innej reprezentacji liczb, używa się modyfikatora, który spełnia rolę zwięzłego komentarza.

Są następujące standardowe modyfikatory:

{tc} uzupełnienie dwójkowe (Two's complement)

{oc} uzupełnienie jedynkowe (One's complement)

{sm} znak-moduł (Sign-magnitude)

{us} moduł bez znaku (Unsigned magnitude)

Dla reprezentacji zmiennopozycyjnej stosuje się modyfikator {flp} z ewentualnym rozszerzeniem określającym typ tej reprezentacji.


Reprezentacja liczb jest implikowana przez zastosowany operator, np. te same zmienne mogą być stałopozycyjnymi lub zmiennopozycyjnymi argumentami dodawania a z kolei w operacjach łańcuchowych będą traktowane jako ciągi zero-jedynkowe.

Przykład:

Var<15:0> #E92D; next ! Var = '1110100100101101 (łańcuch 0-1)

Art neg Var; next ! Art = '0001011011010011 (liczba w tc)

Art 3 rol Art ! Art = '1011011010011000 (łańcuch 0-1)


Są dwa rodzaje książek: te, do których się zagląda i te, które się czyta.

Umberto Eco

Źródła

Opisu omawianych komputerów dokonano na podstawie wielu źródeł - zarówno dokumentacji firmowej, artykułów w czasopismach jak i wielu drobnych materiałów, często o charakterze przyczynkarskim. Poniżej przedstawiono kilka pozycji przeglądowych, które - jak się zdaje - trwale weszły do kanonu lektur z dziedziny wiedzy o komputerach i do których warto zajrzeć.

Książki

Bell C.G., Newell A.: Computer Structures: Readings and Examples. McGraw-Hill, 1971.

Siewiorek D.P., Bell C.G., Newell A.: Computer Structures: Principles and Examples. McGraw-Hill, 1982.

Obydwie pozycje stanowią zestawienie źródłowych artykułów dotyczących wszystkich istotnych konstrukcji komputerów poczynając od pierwszej generacji. Całość połączona komentarzem systematyzującym bardzo obszerny i różnorodny materiał. W książce Bell’a i Newell’a wprowadzono dwa formalizmy PMS i ISP, które są tam konsekwentnie stosowane do opisu wszystkich omawianych komputerów. PMS (Processors, Memories, Switches) jest sformalizowaną notacją graficzną do zapisu struktury na poziomie bloków funkcjonalnych (procesory, układy pamięci, układy przełączające). ISP (Instruction-Set Processor) jest językiem do zapisu architektury na poziomie listy rozkazów.

C.G. Bell, współautor obu książek był twórcą architektury, znakomitych w swoim czasie, minikomputerów firmy Digital Equipment: PDP-8, PDP-11 i VAX.

Hennessy J.L., Patterson D.A.: Computer Organization and Design. (2nd

ed.) M.Kaufmann, 1997.

Bardzo obszerny, świetnie zredagowany podręcznik akademicki zawierający dużą liczbę szczegółowych przykładów praktycznych, zestawy problemów i zadań do każdego działu oraz starannie dobrane, skomentowane odwołania do literatury. Szereg problemów ma swoje aktualizowane odnośniki w Internecie pod adresem http://www.mkp.com/cod2e.htm . Tok wykładu bazuje na szczegółowym opisie architektury MIPS z licznymi odniesieniami porównawczymi do innych współczesnych mikroprocesorów.

Obaj autorzy są pionierami architektury RISC. D.A.Patterson jest twórcą procesora RISC I (Berkeley), od którego wzięła nazwę ta koncepcja i którego architektura jest kontynuowana w architekturze SPARC. J.L.Hennessy kierował projektem MIPS (Stanford Univ.) będącym protoplastą mikroprocesorów obecnie wytwarzanych komercyjnie przez MIPS Computer Systems.

Tanenbaum A.S.: Structured Computer Organization. (3rd

ed.) Prentice-Hall, 1990.

Przystępnie napisany, szeroko stosowany w świecie podręcznik akademicki. Opisuje komputer na kilku poziomach abstrakcji poczynając od sprzętu, przez poziom mikroprogramowania, języka wewnętrznego, systemu operacyjnego i asemblera. Wiele przykładów praktycznych realizacji różnych aspektów organizacji logicznej i architektury (16- i 32-bitowe procesory CISC i RISC). W pierwszym, różniącym się istotnie, wydaniu tej książki, tłumaczonym na polski jako „Organizacja maszyn cyfrowych w ujęciu strukturalnym” (WNT 1980), wiodącymi przykładami były PDP-11 i IBM 360/370.

A.S.Tananbaum jest też autorem podręczników z zakresu sieci komputerowych i systemów operacyjnych.


Blaauw G.A., Brooks F.P.: Computer Architecture. Concepts and Evolution. Addison-Wesley, 1997.

Kompletne i precyzyjne przedstawienie zagadnień ujętych w tytule: koncepcje leżące u podstaw organizacji logicznej komputerów i ich ewolucja w okresie półwiecza od początków w latach 40. aż do współczesności. Ponad połowę objętości tej 1200-stronicowej książki zajmuje „A Computer ZOO” czyli systematyczny przegląd kilkudziesięciu komputerów. Do opisu różnych aspektów architektury stosowany jest konsekwentnie język APL (Iverson, 1962).

Obaj autorzy byli w grupie twórców komputera Strech (IBM, 1961) a później rodziny komputerów IBM S/360, gdzie narodziło się pojęcie „architektury komputerów” w jego obecnym rozumieniu jako zachowania się komputera obserwowanego na poziomie języka wewnętrznego.

Internet

Wśród wielu adresów internetowych godne polecenia ze względu na obszerność i rzetelność podawanych informacji są:

http://wombat.doc.ic.ac.uk/foldoc/index.html

“Free On-Line Dictionary Of Computing” - słownik ok. 13 tysięcy terminów z dziedziny informatyki, ciągle uzupełniany przez ponad 1000 współautorów; dużo odsyłaczy hipertekstowych.

http://www.cs.uregina.ca/~bayko/cpu.html

“Great Microprocessors of the Past and Present” - charakterystyka kilkudziesięciu procesorów (również tych “historycznych”) z dokładnością do list rozkazów, informacje o twórcach techniki komputerowej, nowości („CPU Info Center”), odsyłacze.

http://www.cs.cmu.edu/~koopman/stack_computers/

Aktualizowana wersja on-line książki Ph.J.Koopman’a “Stack Computers: the new wave” z 1989 roku. Poświęcona głównie komputerom o organizacji stosowej; opisy architektury i organizacji kilkunastu procesorów.

Aktualności można szukać na stronach znanych producentów:

http://www.amd.com

Advanced Micro Devices, Inc.

http://www.digital.com

Compaq Computer Co.

http://www.hp.com

Hewlett-Packard Co.

http://www.ibm.com

International Bussiness Machines Co.

http://www.intel.com

Intel Co.

http://www.mips.com

MIPS Technologies, Inc.

http://www.sun.com

Sun Microsystems, Inc.










NSTRUMENTA COMPUTATORIA WYBRANE ARCHITEKTURY...

Documents

Transcript of NSTRUMENTA COMPUTATORIA WYBRANE ARCHITEKTURY...