Buna ziua,
Salutari inginerilor de la TI, astazi reluam constructia compilatorului nostru. Lucreaza cu noi semigrupa I, teoretic grupa aII-a are ora saptamana viitoare. *
Colegii de la Info pot urmari si ei aici, oarecum in avans, comentarii despre lectia curenta despre constructia compilatoarelor.
Luati-va manualul de Constructia compilatoarelor folosind Flex si Bison.
Deschideti manualul la Cap 6, aprox pg 50.(sau pg 51 ed cu coperta verde).
Pentru partea practica aveti nevoie de dosarul Lab4, cu compilatorul construit ca in capitolul al 4-lea al cartii.
Sa incepem sa citim pagina dintai a cap 6. (pg 50 sau 51), [pg 50 pe ebook]
Traducerea primului paragraf nu este ideala, dar ideea este urmatoarea:
Un hardware al unei masini reale este ceva pe care ruleaza un software, executand anumite instructiuni. Ok ?
Masina reala (si echivalenta ei, masina virtuala) trebuie sa:
- inteleaga aceleasi instructiuni ! De acord ?
- sa tina programul si stiva in memorie ! (Vezi lectiile de la materia ASC - Invatam un procesor) tot de pe acest blog. Cititi-le neaparat !
- sa aiba aceiasi registri, chiar daca simulati.
- sa execute un nr minim de "apeluri de sistem" - apeluri la functii complexe ale SO gazda, de obicei pt operatii de I/O (I/O = intrare/iesire).
In esenta, o masina virtuala minimala, care lucreaza doar in mod text trebuie, la modul minimal, sa aiba:
- registrii procesorului, pe care instructiunile ii modifica
- o zona de memorie unde pastreaza programul (si un contor de program PC)
- o zona de memorie care sa fie stiva (si un indicator de stiva SP)
Dati un pic pagina la pagina 58, la implementare, si observati:
- numele instructiunilor in vectorul op_name
- structura unei instructiuni: struct instruction { .... }
- stiva de adrese intregi : int stack[999].
- vectorul de instructiuni care formeaza programul:
struct instruction code[999];
Nota: Va trebui sa existe si o bucla (numita "fetch execution loop" = bucla citeste si executa) care sa ia rand pe rand cate o instructiune la executat.
Sa revenim la paginile 51-52, cititi paragraful despre run-time system-ul pentru limbajul Simple.
Treceti la pg 53: Cititi The Stack Machine pg 53-54 ! Revin imediat cu comentarii.
Comentarii la pg 53:
S-masina a fost inventata pentru a rula limbaje cum era Pascal-ul lui N.Wirth.
Acel Pascal ca si C-ul avea functii (si blocuri). Inregistrarile de activare din stiva si instructiunile care opereaza cu ele noi nu le vom folosi la acest proiect.
Organizarea masinii:
Este un simulator de procesor, care are elementele principale ale procesoarelor cu registri dedicati/specializati.
Exercitiu (de memorie din anul I): La ce se foloseau registrii ?
PC -
SP -
AF -
IR - reg ascuns -
la un procesor cu registri ?
Avem de studiat limbajul masina al acestei masini virtuale... pg 54-56. Detaliez:
Comentarii (la Comentarii pg 54):
Instructiunile arata cam asa (memoria creste ca adresa in jos):
---------------------------------
| Cod instructiune | de exemplu JP sau READ sau STORE
---------------------------------
| subcod de instr. | C 0 L
--------------------------------
| data L | nn nn nn
--------------------------------
| data H | Formeaza un numar cu de 2 ori mai multi biti.
-------------------------------- nn e exprimat prin doua parti binare, L si H
in ordinea HL.
Atentie: In practica vom comasa codul de instructiune si subcodul.
Instructiunile noastre vor avea:
---------------------------------
| Cod instructiune | de exemplu JP C sau READ sau STORE
---------------------------------
| data L | nn nn nn
--------------------------------
| data H | Formeaza un numar cu de 2 ori mai multi biti.
-------------------------------- nn e exprimat prin doua parti binare, L si H
in ordinea HL.
Partea grea acum urmeaza:
1) Luati si studiati fiecare instructiune, de la [pg 54-57], cu exceptia lui OPR, CAL L,N. Cautati eventualele greseli de tipar ! Prof Anthony ne asigura ca sunt !
2) Desenati stiva inainte si dupa executia instructiunii:
Ex: ADD
------- execut
| 7 | ADD <---- T indica aici
------- ----------> --------
| 3 | | 10 | < ---- T-1 indica aici
-------- --------
Aici aveti mult de lucru ! Luati-va timp sa studiati limbajul masinii,
altfel NU veti intelege codul generat de compilator.
Functionarea: pg 57 sus.
Masina ia cate o instructiune pe rand in registrul IR. = Fetch !=
Mareste contorul instructiunilor PC.
Executa dupa felul ei, instructiunea.
Pina cand da de HALT sau epuieaza memoria (si o ia de la capat).
Acum puteti face implementarea:
1) Adaugati in dosarul Lab4 fisierul SM.h
2) Adaugati la inceputul buclei fetch-execute randul de la pagina 60,
pentru depanare (in bucla!)
3) Modificati Simple.y ca:
- sa includa print_code() dar sa nu o foloseasca. (Este in anexa!) pg 61.
- sa includa fetch_execute_cycle() si sa o execute.
Reconstruiti compilatorul: Anexa A2 pg 89.
Dati-i sa compileza ceva... dar sa nu va impresioneze executia, - care nu exista - fiindca compilatorul inca NU genereaza cod !
Trimiteti pe e-mail imaginea executiei. Nu e nimic impresionant!
Succes ! Spor la studiat instructiunile si la implementare.
Ne revedem miercuri cu colegii de la Info.
* Daca alegeti sa lucrati saptamana viitoare este posibil, sau nu, sa aveti o pagina de explicatii mai scurta ca aceasta, sau sa reveniti tot la ea.
Sfarsit pt azi.
Niciun comentariu:
Trimiteți un comentariu