Upload
vuonghanh
View
224
Download
0
Embed Size (px)
Citation preview
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
Kodowanie rozkazów ....................................................................................................................... 26
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
W.Komorowski: Instrumenta computatoria 3
8051 - MIKROKOMPUTER JEDNOUKŁADOWY ................................... 55
Historia ............................................................................................................................................. 55
Rejestry procesora ........................................................................................................................... 55
Pamięć ............................................................................................................................................... 56
Kodowanie rozkazów ....................................................................................................................... 57
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
W.Komorowski: Instrumenta computatoria 4
TRANSPUTER - ELEMENT SIECI PROCESORÓW ................................. 98
Historia ............................................................................................................................................. 98
Rejestry procesora ........................................................................................................................... 99
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
W.Komorowski: Instrumenta computatoria 5
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
W.Komorowski: Instrumenta computatoria 6
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ść
W.Komorowski: Instrumenta computatoria 7
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.
W.Komorowski: Instrumenta computatoria 8
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 - Единая Система ЭВМ).
W.Komorowski: Instrumenta computatoria 9
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:
W.Komorowski: Instrumenta computatoria 10
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.
W.Komorowski: Instrumenta computatoria 11
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.
W.Komorowski: Instrumenta computatoria 12
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
W.Komorowski: Instrumenta computatoria 13
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
W.Komorowski: Instrumenta computatoria 14
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.
W.Komorowski: Instrumenta computatoria 15
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.
W.Komorowski: Instrumenta computatoria 16
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}
W.Komorowski: Instrumenta computatoria 17
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]
W.Komorowski: Instrumenta computatoria 18
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>)
W.Komorowski: Instrumenta computatoria 19
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}
W.Komorowski: Instrumenta computatoria 20
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
ea1 ea1+1; ea2 ea2+1; len len-1)
MVZ D3 SS len L; next rep((len 0) => M[ea1]<0:3> M[ea2]<0:3>; next
ea1 ea1+1; ea2 ea2+1; len len-1)
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.
W.Komorowski: Instrumenta computatoria 21
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.
W.Komorowski: Instrumenta computatoria 22
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.
W.Komorowski: Instrumenta computatoria 23
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.
W.Komorowski: Instrumenta computatoria 24
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).
W.Komorowski: Instrumenta computatoria 25
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
W.Komorowski: Instrumenta computatoria 26
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.
W.Komorowski: Instrumenta computatoria 27
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
W.Komorowski: Instrumenta computatoria 28
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.
W.Komorowski: Instrumenta computatoria 29
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>
W.Komorowski: Instrumenta computatoria 30
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.
W.Komorowski: Instrumenta computatoria 31
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.
W.Komorowski: Instrumenta computatoria 32
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.
W.Komorowski: Instrumenta computatoria 33
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
W.Komorowski: Instrumenta computatoria 34
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.
W.Komorowski: Instrumenta computatoria 35
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.
W.Komorowski: Instrumenta computatoria 36
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.
W.Komorowski: Instrumenta computatoria 37
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.
W.Komorowski: Instrumenta computatoria 38
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^addr 10
Byte relative deferred @B^addr 11 15
Word relative W^addr 12
Word relative deferred @W^addr 13
Longword relative L^addr 14
Longword relative deferred @L^addr 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
W.Komorowski: Instrumenta computatoria 39
MOVB ^5(R4),^7(R3)
90 kod op MOVB
A4 disp(R4); m=A, r=4
05 disp=5
A3 disp(R3); m=A, r=3
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
A6 disp(R6); m=A, r=6
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
), dokładność 16 cyfr dzies.
format G - 64b, zakres (0,56x10-308
, 0,9x10308
), dokładność 15 cyfr dzies.
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.
W.Komorowski: Instrumenta computatoria 40
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.
W.Komorowski: Instrumenta computatoria 41
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
W.Komorowski: Instrumenta computatoria 42
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
W.Komorowski: Instrumenta computatoria 43
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
W.Komorowski: Instrumenta computatoria 44
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
W.Komorowski: Instrumenta computatoria 45
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.
W.Komorowski: Instrumenta computatoria 46
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.Komorowski: Instrumenta computatoria 47
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>
W.Komorowski: Instrumenta computatoria 48
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.
W.Komorowski: Instrumenta computatoria 49
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.Komorowski: Instrumenta computatoria 50
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.
W.Komorowski: Instrumenta computatoria 51
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
Skoki względne (w zakresie
-128..+127 bajtów) według wartości
wskazanego bitu pola V
Skoki względne (w zakresie
-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
W.Komorowski: Instrumenta computatoria 52
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,
W.Komorowski: Instrumenta computatoria 53
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.
W.Komorowski: Instrumenta computatoria 54
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.
W.Komorowski: Instrumenta computatoria 55
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
W.Komorowski: Instrumenta computatoria 56
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ą).
W.Komorowski: Instrumenta computatoria 57
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
W.Komorowski: Instrumenta computatoria 58
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
W.Komorowski: Instrumenta computatoria 59
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>
W.Komorowski: Instrumenta computatoria 60
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
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.
W.Komorowski: Instrumenta computatoria 61
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
W.Komorowski: Instrumenta computatoria 62
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ń.
W.Komorowski: Instrumenta computatoria 63
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
W.Komorowski: Instrumenta computatoria 64
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
W.Komorowski: Instrumenta computatoria 65
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.
W.Komorowski: Instrumenta computatoria 66
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).
W.Komorowski: Instrumenta computatoria 67
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
W.Komorowski: Instrumenta computatoria 68
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.Komorowski: Instrumenta computatoria 69
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]
W.Komorowski: Instrumenta computatoria 70
- 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 -
W.Komorowski: Instrumenta computatoria 71
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
W.Komorowski: Instrumenta computatoria 72
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
W.Komorowski: Instrumenta computatoria 73
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.
W.Komorowski: Instrumenta computatoria 74
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)
W.Komorowski: Instrumenta computatoria 75
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)
W.Komorowski: Instrumenta computatoria 76
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.
W.Komorowski: Instrumenta computatoria 77
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,
W.Komorowski: Instrumenta computatoria 78
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.
W.Komorowski: Instrumenta computatoria 79
Tab. 5.2. Rozkazy komunikacji ze stosem
Nazwa Składnia Wielkość argumentów
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
W.Komorowski: Instrumenta computatoria 80
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
Nazwa Składnia Wielkość argumentów
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.
W.Komorowski: Instrumenta computatoria 81
Tab. 5.4. Rozkazy we-wy
Nazwa Składnia Wielkość argumentów
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
Nazwa Składnia Wielkość argumentów
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.
W.Komorowski: Instrumenta computatoria 82
Tab. 5.6. Rozkazy działające na adresach
Nazwa Składnia Wielkość argumentów
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.
W.Komorowski: Instrumenta computatoria 83
Tab.5.7. Rozkazy działań arytmetycznych
Nazwa Składnia Wielkość argumentów
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^AX AX * r/m {us}
EDX^EAX 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^AX AX * r/m
EDX^EAX 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^AX / r/m {us};
DX DX^AX mod r/m
EAX EDX^EAX / r/m {us};
EDX EDX^EAX mod r/m
Dzielenie IDIV r/m 8 16
32
AL AX / r/m ; AH AX mod r/m
AX DX^AX / r/m ;
DX DX^AX mod r/m
EAX EDX^EAX / r/m ;
EDX EDX^EAX 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.
W.Komorowski: Instrumenta computatoria 84
Tab.5.8. Rozkazy porównań
Nazwa Składnia Wielkość argumentów
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^EAX = r/m<64:0>) =>
(EDX^EAX r/m<64:0>; next
r/m<64:0> ECX^EBX; ZF 1);
(EDX^EAX r/m<64:0>) =>
(EDX^EAX 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
Nazwa Składnia Wielkość argumentów
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^AL<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^AL<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
W.Komorowski: Instrumenta computatoria 85
Tab.5.10. Rozkazy działań logicznych
Nazwa Składnia Wielkość argumentów
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ęć
Nazwa Składnia Wielkość argumentów
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.
W.Komorowski: Instrumenta computatoria 86
Tab.5.12. Rozkazy działające na bitach
Nazwa Składnia Wielkość argumentów
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
Nazwa Składnia Wielkość argumentów
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
(DF=0) => DIr inc DIr; SIr inc SIr;
(DF=1) => DIr dec DIr; SIr dec SIr
Przeszukiwanie łańcucha
SCAS_ {B,W,D} 8,16,32 M[SIr] - Ar; next {EFLAGS}; next
(DF=0) => DIr inc DIr; SIr inc SIr;
(DF=1) => DIr dec DIr; SIr dec SIr
Ładowanie elementów łańcucha
LODS_ {B,W,D} 8,16,32 Ar M[SIr] ; next
(DF=0) => DIr inc DIr; SIr inc SIr;
(DF=1) => DIr dec DIr; SIr dec SIr
Zapamiętywanie elementów łańcucha
STOS_ {B,W,D} 8,16,32 M[DIr] Ar ; next
(DF=0) => DIr inc DIr; SIr inc SIr;
(DF=1) => DIr dec DIr; SIr dec SIr
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.
W.Komorowski: Instrumenta computatoria 87
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
Nazwa Składnia Wielkość argumentów
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
Nazwa Składnia Wielkość argumentów
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).
W.Komorowski: Instrumenta computatoria 88
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.
W.Komorowski: Instrumenta computatoria 89
Tab.5.17. Rozkazy organizujące pętle w programie.
Nazwa Składnia Wielkość argumentów
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
Nazwa Składnia Wielkość argumentów
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:
W.Komorowski: Instrumenta computatoria 90
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.
W.Komorowski: Instrumenta computatoria 91
Tab.5.19. Rozkazy przesłań FPU
Nazwa Składnia Wielkość argumentów
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
m<63:0> ST0 {flp64 flp80}; next ST ST+1
m<80:0> ST0 {flp64 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
m<31:0> ST0 {int32 flp80}; next ST ST+1
m<63:0> ST0 {int64 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
W.Komorowski: Instrumenta computatoria 92
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
W.Komorowski: Instrumenta computatoria 93
Tab.5.24. Rozkazy arytmetyczne FPU
Nazwa Składnia Wielkość argumentów
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
W.Komorowski: Instrumenta computatoria 94
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
Nazwa Składnia Wielkość argumentów
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)
W.Komorowski: Instrumenta computatoria 95
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).
W.Komorowski: Instrumenta computatoria 96
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
W.Komorowski: Instrumenta computatoria 97
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.
W.Komorowski: Instrumenta computatoria 98
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).
W.Komorowski: Instrumenta computatoria 99
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
W.Komorowski: Instrumenta computatoria 100
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
W.Komorowski: Instrumenta computatoria 101
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.
W.Komorowski: Instrumenta computatoria 102
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ół.
W.Komorowski: Instrumenta computatoria 103
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.
W.Komorowski: Instrumenta computatoria 104
Rozkazy arytmetyczne
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.
W.Komorowski: Instrumenta computatoria 105
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).
W.Komorowski: Instrumenta computatoria 106
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.
W.Komorowski: Instrumenta computatoria 107
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}
W.Komorowski: Instrumenta computatoria 108
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).
W.Komorowski: Instrumenta computatoria 109
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.
W.Komorowski: Instrumenta computatoria 110
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.
W.Komorowski: Instrumenta computatoria 111
Λучше менше, да лучше.
В. И. Улянов (Ленин)
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):
W.Komorowski: Instrumenta computatoria 112
%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
W.Komorowski: Instrumenta computatoria 113
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
W.Komorowski: Instrumenta computatoria 114
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).
W.Komorowski: Instrumenta computatoria 115
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.
W.Komorowski: Instrumenta computatoria 116
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]
Rozkazy arytmetyczne
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.
W.Komorowski: Instrumenta computatoria 117
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
W.Komorowski: Instrumenta computatoria 118
Rozkazy przesunięć
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.
W.Komorowski: Instrumenta computatoria 119
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:
W.Komorowski: Instrumenta computatoria 120
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)
W.Komorowski: Instrumenta computatoria 121
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
W.Komorowski: Instrumenta computatoria 122
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
W.Komorowski: Instrumenta computatoria 123
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.
W.Komorowski: Instrumenta computatoria 124
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.
W.Komorowski: Instrumenta computatoria 125
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.
W.Komorowski: Instrumenta computatoria 126
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
Rozkazy arytmetyczne
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.
W.Komorowski: Instrumenta computatoria 127
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.
Rozkazy przesunięć
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
W.Komorowski: Instrumenta computatoria 128
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
W.Komorowski: Instrumenta computatoria 129
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).
W.Komorowski: Instrumenta computatoria 130
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)
W.Komorowski: Instrumenta computatoria 131
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^AC shl C^AC;
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^AC AC + M[e] + C;
ADD (:=(op=7)) => C^AC AC + M[e];
SUB (:=(op=8)) => C^AC AC - M[e];
CMP (:=(op=9)) => Z ((AC - M[e])=0);
SBB (:=(op=10)) => C^AC 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)
W.Komorowski: Instrumenta computatoria 132
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.
W.Komorowski: Instrumenta computatoria 133
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)
W.Komorowski: Instrumenta computatoria 134
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.
W.Komorowski: Instrumenta computatoria 135
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.
W.Komorowski: Instrumenta computatoria 136
;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
W.Komorowski: Instrumenta computatoria 137
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
W.Komorowski: Instrumenta computatoria 138
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
AND #0001H ;czy bylo zgloszenie?
BZ TRZECI ; nie - testuj nastepne
CALL PROB_B ; tak - przejscie do obslugi B
TRZECI: IN PORT_C ;pobranie slowa stanu urzadzenia C
AND #0001H ;czy bylo zgloszenie?
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.
W.Komorowski: Instrumenta computatoria 139
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),
W.Komorowski: Instrumenta computatoria 140
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.
W.Komorowski: Instrumenta computatoria 141
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.
W.Komorowski: Instrumenta computatoria 142
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.
W.Komorowski: Instrumenta computatoria 143
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>
W.Komorowski: Instrumenta computatoria 144
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".
W.Komorowski: Instrumenta computatoria 145
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,
W.Komorowski: Instrumenta computatoria 146
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
W.Komorowski: Instrumenta computatoria 147
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.
W.Komorowski: Instrumenta computatoria 148
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)
W.Komorowski: Instrumenta computatoria 149
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.
W.Komorowski: Instrumenta computatoria 150
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.