FooBar Complete project specs Vollständige Projektbeschreibung Teljes projektleírás

foo BAR Project / Projekt / Projekt:

FooBar

Complete project specs Vollständige Projektbeschreibung Teljes projektleírás Lesson „Virtual machines“ of bioinformatics course at the University of Heidelberg (2003 – 5) Unterrichtseinheit „Virtuelle Maschinen“ des Bioinformatikkurses an der Universität Heidelberg (2003 – 5) „Virtuális gép“ tanóra a Heidelberg-i Egyetem bioinformatika szemináriumán (2003 –'5)

Document / Dokument / Dokumentum: #FB-0087 Project manager / Projektmanager /Projektvezető : Rűdiger Marcus Flaig [email protected] Last modified / Letzte Änderung / Utolsó változtatás: 12/27/2004 / 27. 12. 2004 / 2004.XII.27. Status / Status / Állapot: FINAL / ENDGÜLTIG / VÉGSŐ Verwandt / Related / Lásd még: guidelines/documentation.pdf, guidelines/translatation.pdf, foobar_todo.pdf

BACKGROUND: The FOOBAR is a 16-bit RISC processor intended for embedded devices and machine control. It is going to be a small but powerful all-in-one solution which is primarily meant to be at the interface between the electromechanical parts of a

#FB-0087

HINTERGRUND: Der FOOBAR ist ein 16-Bit-RISC-Prozessor für Embedded Devices und Maschinensteuerung. Er soll eine kleine, aber leistungsfähige Universallösung sein, die in erster Linie an der Schnittstelle zwischen den elektromechanischen Teilen einer Maschine und

1/12

HÁTTÉR: A FOOBAR egy 16-bites RISC processzor ‒ beágyazott készülékekhez és gépirányításra. Kis, de teljesítőképes egyetemes megoldást kíván nyújtani, melynek lényege első sorban az, hogy egy gép elektromechanikus részei és egy olyan, külső

/home/ophis/Dox/equinoctium/foobar/foobar-spec.odt

device and an external computer which einem externen Computer, mit dem er über számítógép közti interfésznél legyen, is going to be connected via USB, LAN or USB, LAN oder einen anderen Anschluß mely egy USB, LAN vagy más csatlakozón some other port. verbunden sein wird, zu finden sein soll. át köttetik be.. FURTHER BACKGROUND: see Flaig, Introduction to Programming in Bioinformatics (University of Heidelberg, 2004), chapter 39.

WEITERER HINTERGRUND: siehe Flaig, Introduction to Programming in Bioinformatics (Universität Heidelberg, 2004), Kapitel 39.

TOVÁBBI HÁTTÉR: lásd: Flaig, Introduction to Programming in Bioinformatics (Heidelberg-i Egyetem, 2004), 39. fejezet.

OBJECTIVE OF PROJECT: Before commencing resource-consuming hardware development, the FOOBAR processor is to be implemented in software as an emulation or „virtual machine“ (VM) in order to test the design, develop essential tools such as assembler, compiler, operating system and libraries, and suggest modifications or improvements to the design.

ZIEL DES PROJEKTES: Vor dem Beginn der ressourcenintensiven Hardwareentwicklung soll der FOOBAR-Prozessor softwaremäßig als Emulation oder „virtuelle Maschine“ (VM) implementiert werden, um das Konzept zu testen, wichtige Werkzeuge wie Assembler, Compiler, Betriebssystem und Bibliotheken zu entwickeln und Abwandlungen oder Verbesserungen des Konzeptes vorzuschlagen.

A PROJEKT CÉLJA, hogy az erőforrásigényes hardver-fejlesztés megkezdése előtt a FOOBAR processzort beágyazzák szoftveresen emulációként vagy 'virtuális gép'(=VM)-ként , ami lehetővé teszi a felépítési terv letesztelését, az olyan, fontos segédeszközök kifejlesztését, mint amilyenek a fordítóprogramok (lsd. gépkód ill. magasabb programozó nyelv), az operációs rendszer és a könyvtárak, valamint a konceptus változtatásainak vagy javításainak javaslatát.

RELATED PROJECTS: FooAsm – crossassembler (Python) Foobasic – BASIC crosscompiler (Python) Spirit Horse – experimental BASIC crosscompiler (Equus)

VERWANDTE PROJEKTE: FooAsm – Crossassembler (Python) Foobasic – BASIC-Crosscompiler (Python) Spirit Horse – experimenteller BASIC-Crosscompiler (Equus)

HASONLÓ PROJEKTEK: FooAsm – kereszt asszembler (Python) Foobasic – BASICkereszt-fordítóprogram (Python) Spirit Horse – kísérleti BASIC - kereszt-fordító program (Equus)

#FB-0087

2/12


BASICS: Language: C (C-99) Toolkits to be used: none Processor: any Operating system: any License: GPL 2.0 or later

GRUNDLAGEN: Sprache: C (C-99) Zu verwendende Toolkits: keine Prozessor: beliebig Operating system: beliebig Lizenz: GPL 2.0 oder später

ALAPOK: Nyelv: C (C-99) Alkalmazandó toolkitek: nincsenek Processzor: bármilyen Operációs rendszer: bármilyen Licenc: GPL 2.0-as, vagy későbbi

THE FOOBAR DESIGN: DAS FOOBAR-KONZEPT: See also „Further Background“ (p. 2). The Siehe auch „Weiterer Hintergrund“ (p. 2). FOOBAR comprises: Der FOOBAR umfaßt:

A FOOBAR FELÉPÍTÉSE: Lásd: „További háttér„“ (2. o.). A FOOBAR tartalma:

- 256 registers, from $00 to $FF, each 16 bit wide. Of these, the $00 register is the program counter („PC“; i.e. it contains the address of the next instruction to be executed; this is increased during each operation, of course), whereas all others are general purpose registers.

- 256 Register von &00 bis &FF mit einer Breite von jeweils 16 bit. Von diesen ist &00 der Programmzähler (program counter, „PC“; d.h., es enthält die Adresse der nächsten auszuführenden Anweisung; diese wird natürlich während jeder Operation erhöht), während alle anderen Allzweckregister sind.

- 256, egyenként 16 bit szélességű regiszter 0x00-tól 0xFF-ig. Ezekből a 0x00 a programszámláló (program counter, „PC“; azaz tartalmazza a következő végrehajtandó utasítás címét; ez természetesen minden művelet alatt egyszer megnő), míg az összes többi általános célú regiszter.

- A 257th register whose value cannot be read or modified directly is the stack pointer („SP“, indicates the first free word on the stack), used by the PUSH and POP operations.

- Ein 257. Register, dessen Wert nicht direkt gelesen oder geändert werden kann, ist der Stackpointer („SP“, bezeichnet das erste freie Wort auf dem Stack), von den Operationen PUSH und POP verwendet.

- Egy 257. regiszter - melynek értékét nem lehet egyenesben olvasni vagy megváltoztatni - a veremmutató (=„SP“ - az első szabad szót jelzi a vermen), a PUSH és POP műveletek használják.

#FB-0087

3/12


- 256 high-speed channels (also from $00 to $FF) for connection both to the electromechanical part and to the higherlevel computer (or in transputer style to other processors). Channel $00 is reserved for I/O with the higher-level computer and $FF for „special purposes“.

- 256 Hochgeschwindigkeitskanäle (ebenfalls von &00 bis &FF) für die Verbindung sowohl mit dem elektromechanischen Teil als auch dem höheren Computer (oder transputerartig mit anderen Prozessoren). Kanal &00 ist für die Kommunikation mit dem höheren Computer reserviert und &FF für „besondere Zwecke“.

- 256 nagysebességű csatorna (szintén 0x00-tól 0xFF-ig) úgy az elektromechanikus résszel, mint a magasabbrendű számítógéppel (vagy transzputer-szerűen más processzorokkal) való összekötöttségre. A 0x00 csatorna a magasabbrendű számítógéppel való kommunikációra van fenntartva, az 0xFF pedig „különleges célokra“.

- 65‘536 words (=128 kb) of built-in memory (as all registers are 16 bit wide, there should be no possibilty for anything to exceed the nefarious 64 kilobytes limit; however, we are doing everything with words [1 word = 2 bytes = 16 bit], resulting - effectively - in 128 kilobytes of usable memory space).

- 65.536 Worte (=128 kb) an eingebautem Speicher (da alle Register 16 Bit breit sind, wäre es nicht möglich, die berüchtigte 64-KBGrenze zu durchbrechen; jedoch geschieht hier alles mit Worten [1 Wort = 2 Bytes = 16 Bit], was zu – effektiv – 128 KB an nutzbarem Speicherplatz führt).

- 65 536 szavas (=128 kb-os) beépített tár (mivel minden regiszter 16 bit széles, nem lehetne a hírhedt 64 KB-os határon áttörni; de itt mindent szóval intézünk [1 szó = 2 bájt = 16 bit], ami - ténylegesen 128 KB-os használható tárhelyhez vezet)

- 65‘536 words (=128 kb) of stack space, physically separate from normal RAM.

- 65‘536 Worte (=128 kb) Stackspeicher, physikalisch vom normalen RAM getrennt.

- 65 536 szavas (= 128 kb-os) veremtár — fizikailag elválasztva a rendes RAM-tól.

- 131‘072 bytes of programmable ROM (the used part of this will be copied into RAM at startup, beginning at address $0000, so this does not become visible to the software – for the VM, this is to be replaced by the load-code-from-file

- 131.072 Bytes an programmierbarem ROM (der verwendete Teil wird beim Systemstart ins RAM kopiert, beginnend an der Adresse &0000, so daß dies für die Software nicht sichtbar wird – für die VM wird dieses Merkmal durch die Code-aus-Datei-laden-Funk-

- 131 072 bájtos programozható ROM (rendszerindításkor előbb bekerül a RAM-ba a felhasznált rész másolata ‒ a 0x0000-as címnél kezdve, úgyhogy ezt a szoftver nem 'láthatja',‒ a VM számára ezt a 'töltsd be kódot az adatállományból' funkció helyet-

#FB-0087

4/12


function).

tion ersetzt).

- A very reduced hardcoded instruction set comprising the instructions listed below (p. 6).

- Ein stark reduzierter, fest verdrahteter - egy erősen redukált, drótosan összeköBefehlssatz, der die nachfolgend aufgelisteten tött utasítás-készlet, mely a következők(S. 6) Befehle umfaßt. ben (6. o.) felsorolt utasításokat tartalmazza .

- Each operation consists of 4 x 16 bit: 1. Opcode (= instruction number) 2. Operator 1 3. Operator 2 4. Operator 3 wherein the places of operators (register numbers or fixed values) which are not actually used are filled by dummy values (usually $0000). The skilled person will appreciate that thus theoretically 65535 opcodes may be implemented, leaving space for plenty of customization. It will also be noted that in the RISC tradition, all operations except for PUT and GET operate on registers only. N.B.: To save tedious checking, the range of opcodes used must be contiguous.

- Jede Operation besteht aus 4 x 16 bit: 1. Opcode (= Befehlsnummer) 2. Operator 1 3. Operator 2 4. Operator 3 wobei die Stellen nicht verwendeter Operatoren (Registernummern oder Festwerte) durch Leerwerte aufgefüllt werden (üblicherweise &0000). Der Fachmann erkennt, daß somit theoretisch 65535 Opcodes implementiert werden können, was viel Platz für die Anpassung an Kundenwünsche läßt. Es ist auch zu erkennen, daß in der RISCTradition alle Operationen außer PUT und GET ausschließlich auf die Register wirken. Nota bene: Um aufwendige Überprüfungen zu vermeiden, muß die Reihe der verwendeten Opcodes zusammenhängend sein.

- Minden művelet 4 x 16 bitből áll: 1. művkód (=utasítás-szám) 2. 1. operátor 3. 2. operátor 4. 3. operátor, amikoris a fel nem használt operátorok (regiszterszámok vagy fixértékek) helyeit üres értékek töltik fel (általában 0x0000).

HOW IT WORKS:

FUNKTIONSWEISE:

MŰKÖDÉSMÓD:

#FB-0087

tesíti).

5/12

Egy szakember felismeri, hogy ezzel elvben 65 535 művkódot lehet beágyazni, ami sok teret enged a vevők igényeihez való alkalmazkodáshoz. Az is feltűnik, hogy a RISC-hagyományban a PUT és GET kivételével minden művelet kizárólag a regiszterre hat. Megjegyzés: A körülményes felülvizsgálások megelőzése érdekében a felhasznált művkódok sorának összefüggőnek kell lennie.


The registers, memory and stack of the VM are emulated by arrays. Access is done by indexing. The operators also form an array (supposed to be immutable), each member being a pointer to a subroutine in a standardized format which does the work when invoked. At the core of the VM there is an infinite loop which is broken only when a SYSTEM operation is encountered. Until then, in each cycle the PC is advanced, the next four words are read and the first of these four is used as an index to access and invoke the instruction within the array.

Register, Speicher und Stack werden durch Arrays emuliert. Der Zugriff erfolgt durch Indizierung. Auch die Operatoren bilden ein (als unveränderlich geltendes) Array, wobei jedes Element ein Zeiger auf eine Subroutine in einem standardisierten Format ist, die beim Aufruf die Arbeit erledigt. Im Kern der VM befindet sich eine Endlosschleife, die nur dann verlassen wird, wenn eine SYSTEM-Anweisung angetroffen wird. Bis dahin wird in jedem Zyklus der Programmzähler weitergeschoben, und das erste der vier Worte wird als Index verwendet, um auf die Anweisung im Array zuzugreifen und sie auszuführen.

A regisztert, a tárat és a vermet adattömbök emulálják. A hozzáférés indexeléssel történik. Az operátorok is egy (megváltozhatatlannak szánt) adattömböt képeznek, melynek minden részeleme mutató egy standardizált formátumú, olyan szubrutinra, ami feladatát felhívásakor végzi el. A VM magvában egy végtelen hurok van, mely csak akkor ér véget, amikor egy RENDSZER-utasítás bukkan fel, de addíg minden hurokban tovább növekszik a programszámláló ‒ ilyenkor az első a négy szóból tárgymutatóként szolgál, azért, hogy el lehessen érni és végre lehessen hajtani az adattömbben levő utasítást.

▶ LIST OF OPERATORS / OPERATORENLISTE / MŰVELET-JEGYZÉK : Opcode MNEMONIC / Syntax 0x0000

NOOP

0x0001

LOAD fixedvalue register Load fixed value (1) into register (2).

0x0002

GET addressregister register

Fetch the contents of memory Hole Inhalt der in Adreßregister (1) location contained in address register bezeichneten Speicherzelle in Register (1) into register (2). (2).

0x0003

PUT register

Place the content of register (1) into

#FB-0087

No operation.

Keine Operation.

Ne follyon művelet!

Lade Festwert (1) in Register (2).

Töltsd az 1. fixértéket a 2. regiszterbe! Hozd az 1. címregiszterben található tárrekesz tartalmát a 2. regiszterbe !

Schreibe Inhalt von Register (1) in die in Írd az 1. regiszter tartalmát a 2. címre-

6/12


Opcode MNEMONIC / Syntax addressregister

the memory location contained in addressregister (2).

Adreßregister (2) bezeichnete Speicherzelle.

0x0004

READ channel register

Scans the contents of channel (1) into the register (2).

Lies Inhalt von Kanal (1) in Register (2). Olvasd be az 1. csatorna tartalmát a 2. regiszterbe!

0x0005

WRITE register channel

Write the contents of register (1) to channel (2).

Schreibe Inhalt von Register (1) in Kanal Írd az 1. regiszter tartalmát a 2. csator(2). nába!

0x0006

MOVE from to

Copy contents of register (1) to register (2).

Kopiere Inhalt von Register (1) nach Register (2).

Másold az 1. regiszter tartalmát a 2. regiszterbe!

0x0007

TEST register bitnumber Check bit (2) in register (1).

Prüfe Bit (2) in Register (1).

Ellenőrizd a 2. bitet az 1. regiszterben!

0x0008

ADD reg1 reg2 reg3

Add contents of reg. (1) and reg. (2) and write result to reg. (3).

Addiere Inhalte von Reg. (1) und Reg. (2) Összegezd az 1. és 2. regiszter tartalmát, und schreibe Ergebnis in Reg. (3). majd írd az eredményt a 3. regiszterbe!

0x0009

SUB reg1 reg2 reg3

Subtract contents of reg. (2) from reg. (1) write result them to reg. (3).

Subtrahiere Inhalt von Reg. (2) von Reg. Vond ki az 1. regiszter tartalmából a 2.-ét, (1), schreibe Ergebnis in Reg. (3). majd írd az eredményt a 3. regiszterbe!

0x000A

MUL reg1 reg2 reg3

Multiply contents of reg. (1) and reg. Multipliziere Inhalte von Reg. (1) und (2) write result them to reg. (3). Reg. (2), schreibe Ergebnis in Reg. (3).

0x000B

DIV reg1 reg2 reg3

Divide contents of reg. (1) by reg. (2) and write result to reg. (3).

Dividiere Inhalt von Reg. (1) durch Reg. Oszd el az 1. regiszter tartalmát a 2.-éval, (2), schreibe Ergebnis in Reg. (3). majd írd az eredményt a 3. regiszterbe!

0x000C

MOD reg1 reg2 reg3

Calculate modulo of reg. (1) by reg. (2) and write result to reg. (3).

Berechne Rest von Reg. (1) durch Reg. (2), schreibe Ergebnis in Reg. (3).

Írd az 1. regiszter a 2.-kal való osztása utáni maradékot a 3. regiszterbe!

0x000D

ISEQU reg1 reg2

Compare the contents of reg. (1) and reg. (2) and set an internal flag (used by LIFT and LIFF) to true if they are equal, to false otherwise.

Vergleiche Inhalte von Reg. (1) und Reg. (2) und setze internes Flag (von LIFT und LIFF verwendet) auf wahr, falls gleich, sonst auf falsch.

Hasonlítsd össze az 1. és 2. regiszter tartalmát, majd állítsd a (LIFT és LIFF által használt) belső állapotjelzőt egyenlőség esetén igaz-ra, máskülönben hibás-ra!

0x000E

ISNEQ reg1 reg2

Compare the contents of reg. (1) and reg. (2) and set an internal flag (used by LIFT and LIFF) to true if they are not equal, to false otherwise.

Vergleiche Inhalte von Reg. (1) und Reg. (2) und setze internes Flag (von LIFT und LIFF verwendet) auf wahr, falls ungleich, sonst auf falsch.

Hasonlítsd össze az 1. és 2. regiszter tartalmát, majd állítsd a (LIFT és LIFF által használt) belső állapotjelzőt különbözés esetén igaz-ra, máskülönben hibás-ra!

#FB-0087

7/12

giszterben levő tárrekeszbe!

Szorozd össze az 1. és 2. regiszter tartalmát, majd írd az eredményt a 3. reg.-be!


Opcode MNEMONIC / Syntax 0x000F

ISGTR reg1 reg2

Compare the contents of reg. (1) and reg. (2) and set an internal flag (used by LIFT and LIFF) to true if reg(1) > reg(2), to false otherwise.

Vergleiche Inhalte von Reg. (1) und Reg. (2) und setze internes Flag (von LIFT und LIFF verwendet) auf wahr, falls Reg.(1) > Reg.(2), sonst falsch.

Hasonlítsd össze az 1. és 2. regiszter tartalmát, majd állítsd a (LIFT és LIFF által használt) belső állapotjelzőt igaz-ra, ha az 1. >2. reg., máskülönben hibás-ra!

0x0010

ISLSR reg1 reg2

Compare the contents of reg. (1) and reg. (2) and set an internal flag (used by LIFT and LIFF) to true if reg(1) < reg(2), to false otherwise.

Vergleiche Inhalte von Reg. (1) und Reg. (2) und setze internes Flag (von LIFT und LIFF verwendet) auf wahr, falls Reg.(1) < Reg.(2), sonst falsch.

Hasonlítsd össze az 1. és 2. regiszter tartalmát, majd állítsd a (LIFT és LIFF által használt) belső állapotjelzőt igaz-ra, ha az 1.<2. reg., máskülönben hibás-ra!

0x0011

ISGEQ reg1 reg2

Compare the contents of reg. (1) and reg. (2) and set an internal flag (used by LIFT and LIFF) to true if reg(1) ≥ reg(2), to false otherwise.

Vergleiche Inhalte von Reg. (1) und Reg. (2) und setze internes Flag (von LIFT und LIFF verwendet) auf wahr, falls Reg.(1) ≥ Reg.(2), sonst falsch.

Hasonlítsd össze az 1. és 2. regiszter tartalmát, majd állítsd a (LIFT és LIFF által használt) belső állapotjelzőt igaz-ra, ha az 1.≥2. reg., máskülönben hibás-ra!

0x0012

ISLEQ reg1 reg2

Compare the contents of reg. (1) and reg. (2) and set an internal flag (used by LIFT and LIFF) to true if reg(1) ≤ reg(2), to false otherwise.

Vergleiche Inhalte von Reg. (1) und Reg. (2) und setze internes Flag (von LIFT und LIFF verwendet) auf wahr, falls Reg.(1) ≤ Reg.(2), sonst falsch.

Hasonlítsd össze az 1. és 2. regiszter tartalmát, majd állítsd a (LIFT és LIFF által használt) belső állapotjelzőt igaz-ra, ha az 1.≤2. reg., máskülönben hibás-ra!

0x0013

AND reg1 reg2 reg3

Perform bitwise AND of reg. (1) and reg. (2) and write the result into reg. (3).

Berechne bitweises UND von Reg. (1) und Reg. (2) und schreibe Ergebnis in Reg. (3).

Számítsd ki bitenként az 1. és 2. regiszter ÉS-jét, majd írd az eredményt a 3. regiszterbe!

0x0014

OR reg1 reg2 reg3

Perform bitwise OR of reg. (1) and reg. (2) and write the result into reg. (3).

Berechne bitweises ODER von Reg. (1) und Reg. (2) und schreibe Ergebnis in Reg. (3).

Számítsd ki bitenként az 1. és 2. regiszter VAGY-ját, majd írd az eredményt a 3. regiszterbe!

0x0015

NOT reg1 reg2

Perform bitwise NOT of reg. (1) and write the result into reg. (2).

Berechne bitweises NICHT von Reg. (1) und schreibe Ergebnis in Reg. (2).

Számítsd ki bitenként az 1. és 2. reg. NEjét, majd írd az eredményt a 3. reg.-be!

0x0016

XOR reg1 reg2 reg3

Perform bitwise XOR of reg. (1) and reg. (2) and write the result into reg. (3).

Berechne bitweises XOR von Reg. (1) und Reg. (2) und schreibe Ergebnis in Reg. (3).

Számítsd ki bitenként az 1. és 2. reg. XORját, majd írd az eredményt a 3. regiszterbe!

0x0017

LIFT reg value

Load fixed value (2) into reg. (1) if

Lade Festwert (2) in Reg. (1), wenn die

Töltsd a 2. fixértéket az 1. reg.-be, ha az

#FB-0087

8/12


Opcode MNEMONIC / Syntax most recent ISxxx operation yielded true. (Usually used with $00 to generate conditional jump. !)

letzte ISxxx-Operation ein wahr ergab. utolsó ISxxx-művelet igaz-t eredménye(Üblicherweise mit &00 verwendet, um zett! (Általában 0x00-lal használják, hogy konditionale Sprünge zu bewirken. !) kondicionális ugrások jöjjenek létre. !) Lade Festwert (2) in Reg. (1), wenn die letzte ISxxx-Operation ein falsch ergab. (Üblicherweise mit &00 verwendet, um konditionale Sprünge zu bewirken. !)

0x0018

LIFF reg value

Load fixed value (2) into reg. (1) if most recent ISxxx operation yielded FALSE. (Usually used with $00 to generate conditional jump. !)

Töltsd a 2. fixértéket az 1. reg.-be, ha az utolsó ISxxx-művelet hibás-t eredményezett! (Általában a 0x00-ra használják,hogy kondicionális ugrások jöjjenek létre. !)

0x0019

PUSH reg

Push contents of reg. (1) onto the Lege Inhalt von Reg. (1) auf den Stack stack and increase stack pointer (SP). und erhöhe den Stackpointer (SP).

Helyezd az 1. reg. tartalmát a verembe, majd növeld meg a veremmutatót (=SP)!

0x001A

POP reg

Get the top of the stack into reg. (1) and decrease stack pointer (SP).

Nimm obersten Wert vom Stack, schreibe ihn in Reg. (1) und verringere den Stackpointer (SP).

Tedd át a verem legfelső értékét az 1. regiszterbe, és csökkents a veremmutatón (SP)!

0x001B

STATE channel reg

Read status of channel (1) into reg. (2).

Lies Status von Kanal (1) in Reg. (2).

Olvasd az 1. csatorna állapotát a 2. reg.-be!

0xFFFF

SYSTEM x

Execute special operation x: SYSTEM $0000 shuts down system, SYSTEM $FFFF restarts.

Spezialanweisung x: SYSTEM &0000 = Systemhalt, SYSTEM &FFFF = Neustart.

Hajtsd végre az x. sz. speciális feladatot: SYSTEM 0x0000 = rendszerleállítás, SYSTEM 0xFFFF = újraindítás.

▶ CODE SAMPLE 1 / CODEBEISPIEL 1 / 1. KÓDPÉLDA: Calculate the Nth Fibonacci number where N is supplied via channel 0 (i.e. from the higher level computer); write result back to channel 0. Left hand column: mnemonics. Right hand column: hex code. Berechne die N-te Fibonacci-Zahl, wobei N über Kanal 0 eingespeist wird (d. h. von dem höheren Computer); schreibe Ergebnis zurück in Kanal 0. Linke Spalte: Mnemonischer Kürzel. Rechte Spalte: Hexcode. Számítsd ki az N. Fibonacci-számot úgy, hogy N betáplálása a 0. csatornán át folyik (azaz egy felsőbbrendű számítógépből); majd írd az eredményt vissza a 0. csatornába! Bal hasáb: mnemonikus rövidítés, jobb hasáb: hex-kód.

#FB-0087

9/12


; Use reg. $10, $11, $12 for work, $15 and $20 as counter load 0001 $03 ; one cycle at each time load 0001 $10 ; the 1st member load 0001 $11 ; the 2nd member load 0003 $15 ; beginning with the 3rd member read #00 $20 ; up to this member write $10 #00 ; print 1st... write $11 #00 ; ...and 2nd member :loopus add $10 $11 $12 ; calculate next member write $12 #00 ; show it isgeq $15 $20 ; end reached? lift $00 :cut_it_out ; if so, quit add $03 $15 $15 ; increment counter move $11 $10 ; the last... move $12 $11 ; ...two members load :loopus $00 ; next cycle :cut_it_out system 0000 ; ciao bello

Address (0000) (0004) (0008) (000c) (0010) (0014) (0018)

Opcode 0x0001 0x0001 0x0001 0x0001 0x0004 0x0005 0x0005

1st op 0x0001 0x0001 0x0001 0x0003 0x0000 0x0010 0x0011

2nd op 0x0003 0x0010 0x0011 0x0015 0x0020 0x0000 0x0000

3rd op 0x0000 0x0000 0x0000 0x0000 0x0000 0x0000 0x0000

(001c) (0020) (0024) (0028) (002c) (0030) (0034) (0038)

0x0008 0x0005 0x0011 0x0017 0x0008 0x0006 0x0006 0x0001

0x0010 0x0012 0x0015 0x0000 0x0003 0x0011 0x0012 0x001c

0x0011 0x0000 0x0020 0x003c 0x0015 0x0010 0x0011 0x0000

0x0012 0x0000 0x0000 0x0000 0x0015 0x0000 0x0000 0x0000

(003c)

0xffff

0x0000

0x0000

0x0000

▶ CODE SAMPLE 2 / CODEBEISPIEL 2 / 2. KÓDPÉLDA: Calculate prime numbers between 1 and 30000 as calculated using the Foobasic compiler. Berechnung der Primzahlen zwischen 1 und 30000 unter Verwendung des Foobasic-Compilers. Számítsd ki a prímszámokat 1 és 30 000 közt a Foobasic (gépkódra )fordító bevetésével! ; ; ; ; ; ; ; ; ; ;

10 20 30 40 50 60 70 80 90 100

dim p 30000 p[0]:=2 primes:=1 for i:=3 to 30000 do for j:=0 to primes-1 do if i mod p[j]==0 then go to 110 next j print i p[primes]:=i primes:=primes+1

#FB-0087

10/12


; 110 next i ; Array offsets: {'p': 65535} ; FooBar assembly code to follow: ;;; :L10 :L20 LOAD 0002 $ff ; push 2 LOAD 0000 $fe ; push 0 ;; indexing on the left hand side: p[$fd], Offset=0xffff LOAD ffff $fd SUB $fd $fe $fe PUT $ff $fe ;; :L30 LOAD 0001 $fd ; push 1 MOVE $fd $10 ; assign to primes :L40 LOAD 0003 $fd ; push 3 MOVE $fd $11 ; assign to i :LFOR0000BEG ; 'for' loop LOAD 7530 $fd ; push 30000 MOVE $11 $fc ; push i ISLSR 0xfd 0xfc 0xfd ; < LIFT $00 :LFOR0000END ; if true then go to :LFOR0000END :L50 LOAD 0000 $fc ; push 0 MOVE $fc $12 ; assign to j :LFOR0001BEG ; 'for' loop MOVE $10 $fc ; push primes LOAD 0001 $fb ; push 1 SUB 0xfc 0xfb 0xfc ; MOVE $12 $fb ; push j ISLSR 0xfc 0xfb 0xfc ; < LIFT $00 :LFOR0001END ; if true then go to :LFOR0001END :L60 MOVE $11 $fb ; push i MOVE $12 $fa ; push j ; indexing p[$fa]: Offset=0xffff, next free reg=$f9 LOAD ffff $f9 SUB $f9 $fa $fa

#FB-0087

11/12


GET $fa $fa ;; MOD 0xfb 0xfa 0xfb ; mod LOAD 0000 $fa ; push 0 ISEQU 0xfb 0xfa 0xfb ; == LIFT $00 :L110 ; if true then go to :L110 :L70 MOVE $12 $fa ; push j LOAD 0001 $f9 ; push 1 ADD 0xfa 0xf9 0xfa ; + MOVE $fa $12 ; assign to j LOAD :LFOR0001BEG $00 ; go to :LFOR0001BEG :LFOR0001END ; next 'for' :L80 MOVE $11 $fa ; push i WRITE 0xfa #00 ; print :L90 MOVE $11 $fa ; push i MOVE $10 $f9 ; push primes ;; indexing on the left hand side: p[$f8], Offset=0xffff LOAD ffff $f8 SUB $f8 $f9 $f9 PUT $fa $f9 ;; :L100 MOVE $10 $f8 ; push primes LOAD 0001 $f7 ; push 1 ADD 0xf8 0xf7 0xf8 ; + MOVE $f8 $10 ; assign to primes :L110 MOVE $11 $f8 ; push i LOAD 0001 $f7 ; push 1 ADD 0xf8 0xf7 0xf8 ; + MOVE $f8 $11 ; assign to i LOAD :LFOR0000BEG $00 ; go to :LFOR0000BEG :LFOR0000END ; next 'for' NOOP ; just don't do anything NOOP ; just don't do anything SYSTEM 0000 ; regular shutdown

#FB-0087

12/12


FooBar Complete project specs Vollständige Projektbeschreibung Teljes projektleírás

Recommend Documents