În cadrul acestei teme veti implementa generarea de cod pentru limbajul LCPL.
Va trebui să realizaţi în limbajul C++, porţiunea responsabilă cu generarea cod LLVM IR, folosind LLVM C++ API. Programul vostru va trebui să primească la intrare output-ul temei 1 şi să genereze un fisier cu cod corect LLVM IR.
Documentaţia principală în cadrul acestei teme va fi LLVM C++ API și LLVM IR. Rezultatul programului realizat de voi poate folosi tool-urile LLVM pentru a genera cod pentru x86 si pentru a se executa.
Pentru generarea de cod veti folosi LLVM C++ API, similar cu ceea ce ați învățat în laboratorul 5. De asemenea, vă recomandăm să studiați și tutorialul de generare de cod de aici http://llvm.org/releases/3.6.0/docs/tutorial/LangImpl3.html.
Arhiva de pornire conține codul generat pentru un nod de tip clasa si pentru metode vide.
Tehnica folosită pentru implementarea generării de cod se bazează pe ASTVisitor. Voi trebuie sa implementați funcțiile visit pentru celelalte tipuri de noduri și să le completați pe cele deja puse ca exemplu, dacă este cazul.
Nu sunteti obligați să folosiți abordarea sugerată în arhiva de pornire. Însă, codul generat trebuie sa fie cod LLVM IR valid și trebuie să producă rezultatele corecte.
Vă recomandam să începeți cu înțelegerea documentației:
Odată ce ați citit documentația puteți trece la implementarea generării de cod, parucrgând următorii pași:
startup
care creează obiectul de tip Main si apelează metoda main.Puteţi organiza generatorul de cod în două etape: în prima se decide layout-ul obiectelor pentru fiecare clasă (deplasamentele atributelor şi ale metodelor), iar în a doua se generează cod pentru fiecare metodă (inclusiv metodele definite implicit pentru iniţializare).
* Reprezentarea unui obiect în memorie arată astfel:
Offset | Descriere |
---|---|
+0 | Pointer către rtti al clasei din care face parte obiectul |
+4 | Atributele obiectului - întregi pe 4 bytes sau referinţe către alte obiecte. |
Referinţa la un obiect este adresa din memorie a acelui obiect.
* Reprezentarea rtti in memorie arată astfel
Offset | Descriere |
---|---|
+0 | Pointer către obiectul String care reprezintă numele clasei |
+4 | Dimensiunea in bytes a obiectului, incluzând informația de runtime |
+8 | Pointer către informația de runtime a clasei parinte, NULL pentru Object |
+12 | Tabela de metode |
Pe prima poziție din tabela de metode se va afla adresa constructorului clasei, urmând apoi adresele metodelor din clasa parinte și metodele clasei.
Pentru:
class Main inherits IO main : [out "Hello world!"]; end; end;
se genereaza urmatoarele:
* Obiectul de tip String care reprezintă numele clasei
@.str = constant [5 x i8] c"Main\00" @NMain = global %struct.TString { %struct.__lcpl_rtti* @RString, i32 4, i8* getelementptr ([5 x i8]* @.str, i32 0, i32 0) }
* Informația de runtime pentru clasa Main
%0 = type { %struct.TString*, i32, %struct.__lcpl_rtti*, [7 x i8*] } @RMain = global %0 { %struct.TString* @NMain, i32 4, %struct.__lcpl_rtti* @RIO, [7 x i8*] [ i8* bitcast (void (%struct.TMain*)* @Main_init to i8*), i8* bitcast (void (%struct.TObject*)* @M6_Object_abort to i8*), i8* bitcast (void (%struct.TObject*)* @M6_Object_typeName to i8*), i8* bitcast (%struct.TIO* (%struct.TObject*)* @M6_Object_copy to i8*), i8* bitcast (%struct.TString* (%struct.TIO*)* @M2_IO_in to i8*), i8* bitcast (void (%struct.TIO*, %struct.TString*)* @M2_IO_out to i8*), i8* bitcast (void (%struct.TMain*)* @M4_Main_main to i8*) ]}
Clasa Main nu are atribute proprii, prin urmare dimensiunea ei este de 4 bytes, dimensiunea pointerului la rtti. Main este derivată din clasa IO, deci informația de parent va arata către rtti-ul clasei IO (@RIO). În tabela de funcții a clasei Main, pe prima poziție este adresa constructorului clasei Main_init, apoi urmează metodele clasei părinte IO și metoda main a clasei Main.
* Constructorul clasei
define void @Main_init(%struct.TMain* %self) { %1 = alloca %struct.TMain* store %struct.TMain* %self, %struct.TMain** %1 %2 = load %struct.TMain** %1 %3 = bitcast %struct.TMain* %2 to %struct.TObject* call void @Object_init(%struct.TObject* %3) ret void }
Din constructorul clasei Main se apelează constructorul clasei părinte, pentru a se inițializa atributele clasei părinte.
* Metodele clasei
define void @M4_Main_main(%struct.TMain* %self) { ; Prologue - save parameters %1 = alloca %struct.TMain* store %struct.TMain* %self, %struct.TMain** %1 ... }
Primul parametru pentru orice funcție generată va conține adresa obiectului de care aceasta aparține (self). Variabilele LCPL pot fi pe stivă sau în registre. Structurile precum tabelele virtuale sau informațiile de runtime sunt variabile globale LLVM IR.
N<NumeClasă>
. T<NumeClasă>
R<NumeClasă>
<NumeClasă>_init
M<N>_<NumeClasă>_<NumeMetodă>
, unde N este numărul de caractere al numelui claseiBiblioteca de runtime LCPL implementează funcţionalitatea claselor de bază aşa cum este descrisă în manualul limbajului LCPL. În codul generat metodele din bibliotecă pot fi folosite respectând convenţia ca obiectul apelant să fie primul parametru al apelului. Este foarte recomandat să folosiţi această convenţie pentru toate clasele şi metodele, nu doar pentru clasele de bază.
Punctul de intrare în program este funcția main din biblioteca de runtime. În ea este apelată funcția startup care:
Deoarece metoda main poate exista in clasa Main sau intr-o clasă din care este derivată clasa Main, nu se poate ști la runtime care este indexul metodei main in tabela de metode a clasei Main. Prin urmare, codul generat de voi va trebui sa conțina si funcția startup
care apelează funcția main prin vtable, cu indexul corect, cunoscut la momentul generării codului.
API-ul complet pentru generarea de cod LLVM il gasiti pe site-ul oficial llvm.org
static ConstantInt * ConstantInt::get (LLVMContext &Context, const APInt &V);
Constant * ConstantDataArray::getString ( LLVMContext &Context, StringRef Str, bool AddNull = true ) [static]
///\ creare structura static StructType * StructType::create (LLVMContext &Context, StringRef Name) ///\ adaugare campuri void setBody (ArrayRef< Type * > Elements, bool isPacked=false)
static FunctionType * FunctionType::get (Type *Result, ArrayRef< Type * > Params, bool isVarArg);
exemplu pentru void func(int, int);
///\ pregatire parametri std::vector<llvm::Type*> func_args; func_args.push_back(llvm::IntegerType::get(mod->getContext(), 32)); func_args.push_back(llvm::IntegerType::get(mod->getContext(), 32)); FunctionType* func_type = FunctionType::get( llvm::Type::getVoidTy(mod->getContext()), // rezultat func_args, // parametri false); // isVarArg
Este recomandat sa creati si pointerul catre FunctionType
PointerType* pointer_func_type = PointerType::get(func_type, 0);
static Function * Create (FunctionType *Ty, // pt exemplul de mai sus //func_type// LinkageTypes Linkage, const Twine &N="", // numele functiei Module *M=nullptr) // modulul din care face part
void setCallingConv (CallingConv::ID CC)
In tema setCallingConv va primi parametru:
CallingConv::C
static BasicBlock * Create (LLVMContext &Context, const Twine &Name="", Function *Parent=0, BasicBlock *InsertBefore=0)
Atentie: Prototipurile de mai jos sunt doar sugestii. Studiati LLVM API si alegeti varianta care considerati ca se potriveste cel mai bine cazului pentru care generati cod.
// alocare spatiu pe stiva AllocaInst (const Type *Ty, const Twine &Name, BasicBlock *InsertAtEnd) // salvare in memorie StoreInst (Value *Val, Value *Ptr, bool isVolatile, BasicBlock *InsertAtEnd) // incarca din memorie LoadInst (Value *Ptr, const char *NameStr, bool isVolatile, BasicBlock *InsertAtEnd) // incarca un camp dintr-o structura static GetElementPtrInst * Create (Value *Ptr, Value *Idx, const Twine &NameStr, BasicBlock *InsertAtEnd) // operatii aritmetice binare static BinaryOperator * Create (BinaryOps Op, // Instruction::Add | Instruction::Sub ... Value *S1, Value *S2, const Twine &Name, BasicBlock *InsertAtEnd) // operatiile unare in llvm sunt tot operatii binare cu un pseudo operand static BinaryOperator * CreateNeg (Value *Op, const Twine &Name, BasicBlock *InsertAtEnd) // comparatii si branch ICmpInst (BasicBlock &InsertAtEnd, Predicate pred, Value *LHS, Value *RHS, const Twine &NameStr="") static BranchInst * Create (BasicBlock *IfTrue, BasicBlock *IfFalse, Value *Cond, // rezultatul comparatiei (new ICmpInst) BasicBlock *InsertAtEnd)
Fisierul generat de voi este un modul scris în limbajul intermediar LLVM. Acest fişier va fi apoi transformat în asamblare pentru arhitectura target de catre llc, legat cu biblioteca de runtime şi apoi executat pe plaforma target. O descriere exhaustiva a limbajului se găseşte în documentaţia oficială; mai jos sunt descrise pe scurt elementele de limbaj necesare pentru temă.
Un modul LLVM conţine definiţii de funcţii, de variabile globale şi declaraţii de simboluri externe modulului. Un obiect global (funcţie sau variabilă globală) este reprezentat prin adresa lui de memorie. Această adresă este un identificator care începe cu caracterul '@' şi poate conţine litere, cifre, caracterele '.' si '$' .
Cateva exemple:
; Un comentariu LLVM incepe cu caracterul ; ; Definiţia unei variabile globale - şir de caractere ; Numele ".str1" este declarat "internal" pentru a nu intra in conflict cu alte nume ; Variabila @.str1 este "constant" - nu îşi va schimba valoarea pe parcursul programului @.str1 = internal constant [13 x i8] c"Hello world!\00" ; Definiţia unei funcţii define i32 @addOne(i32 %arg) { %1 = add i32 %arg, 1 ret i32 %1 } ; Declaraţia unei funcţii externe (în cazul nostru, implementată în biblioteca runtime) declare void @__lcpl_checkNull(i8*)
Tipurile de bază sunt valori care pot fi tinute în regiştri. In cazul LCPL, acestea sunt valori de tip întreg (i32), caracter (i8) sau adresă de memorie, care este pointer/referinţă la un alt tip (de exemplu i32*).
LLVM permite tipuri complexe: tablouri: [ 5 x i8 ], structuri: { i32, i8*, i8* }, pointeri la funcţii : i32 (i32,i32)* . Constructia %nume=type expresie tip
crează un alias %nume
, ce va fi înlocuit cu expresie tip
oriunde apare in program.
; tipul care reprezintă informația de runtime pentru clasa String %0 = type { %struct.TString*, i32, %struct.__lcpl_rtti*, [7 x i8*] } ; Obiectul RMain reprezintă informatia de runtime pentru clasa Main ; si este de tip %0, definit mai sus @RMain = global %0 { %struct.TString* @NMain, i32 4, %struct.__lcpl_rtti* @RIO, ...
O definiţie de variabilă globală trebuie iniţializată cu valori constante. In plus, variabilele globale de tip tablou de i8 pot fi initializate cu siruri de caractere. Urmatoarele caractere nu pot fi reprezentate direct si trebuie inlocuite cu valoarea lor hexazecimala:
” | \22 |
\ | \5C |
\n | \0A |
\r | \0D |
null | \00 |
Inlocuirea se face astfel:
1) Se fac modificarile scriind un buffer char *<input_string> (C) 2) sprint(<output_string>, "%s", <input_string>) - pentru a ne asigura ca se trateaza celelalte caractere speciale (de exemplu \t) 3) llvm::Constant *const_str = ConstantDataArray::getString(module->getContext(), <output_string>, true);
Expresiile folosite la iniţializare pot conţine conversii de pointeri, de exemplu:
bitcast i32 (i32,i32)* @main.isEven to i8 * | Converteşte adresa funcţiei main.isEven la un pointer la un sir de i8 |
i8* getelementptr ([7 x i8]* @s62, i32 0, i32 2) | Citeşte adresa celui de-al treilea element din şirul de 7 caractere s62 |
char (*s62)[7]; &(s62[0][2]);
O funcţie în LLVM este alcătuită din mai multe basic blocuri. Un basic bloc începe cu un label şi se termină cu o instrucţiune de salt, condiţionat sau nu (de exemplu br
sau ret
). Instrucţiunea de salt este obligatorie chiar dacă din basic blocul curent se trece direct în basic blocul urmator. Numele unui label este un identificator local funcţiei, ce începe cu %. De exemplu:
Cod Cint m(int c) { if (c>20) f(); return c; } | Cod LLVM IRdefine i32 @m(i32 %c) { %1 = icmp sgt i32 %c, 20 br i1 %1, label %L2, label %L3 L2: call void @f() br label %L3 L3: ret i32 %c } |
Un simbol local unei funcţii începe cu caracterul %, urmat de un identificator sau de un număr. Numerele trebuie alocate consecutiv şi încep de la 1 pentru fiecare funcţie. Simbolurile locale sunt valori care pot fi tinute în regiştri.
Fiecare simbol local poate fi scris o singură dată, într-o singură instrucţiune în funcţie. LLVM este o reprezentare în forma SSA (Single Static Assignment). Această restricţie poate cauza probleme in diverse cazuri; pentru LCPL de exemplu
* rezultatul unei expresii de tip if
trebuie calculat pe fiecare ramură.
* o variabilă locală LCPL se află în partea stângă a unei atribuiri în mai multe locuri in program (de exemplu x ← 1; x ← x + 1;
)
Pentru a rezolva această problemă, LLVM introduce instrucţiunea phi. Aceasta se poate găsi doar la începutul unui basic bloc, şi atribuie o valoare in funcție de ramura pe care programul a ajuns din basic blocul precedent. De exemplu:
Cod Cint m(int c) { return c > 20 ? f() : g() ; } | Cod LLVMdefine i32 @m(i32 %c) { %1 = icmp sgt i32 %c, 20 br i1 %1, label %L2, label %L4 L2: %2 = call i32 @f() br label %L6 L4: %3 = call i32 @g() br label %L6 L6: %4 = phi i32 [ %2, %L2 ], [ %3, %L4 ] ret i32 %4 } |
Acesta este singurul caz in care aveți nevoie de instrucțiunea phi. În rest se recomandă generarea de simboluri locale temporare care sa țină rezultatele intermediare din evaluarea expresiilor.
În ceea ce privește variabilele definite de utilizator, ele trebuie alocate pe stivă. LLVM pune la dispozitie instrucţiunea alloca
, ce aloca spaţiu pe stivă pentru o variabilă şi întoarce un pointer la acea variabilă. Instrucţiunile load
şi store
transferă o valoare din memorie într-un registru şi înapoi. Un exemplu:
int m() { int a=42; return a; } | define i32 @m() { %a = alloca i32 store i32 42, i32* %a %1 = load i32* %a ret i32 %1 } |
De remarcat în exemplul de mai sus că %a este un registru, ce conţine un pointer către un int aflat pe stivă. %a nu conţine valoarea 42, ci adresa unei locaţii de memorie care conţine valoarea 42!
(Exemplele folosesc limbajul C, deoarece permite un cod LLVM mai simplu de înţeles decât codul LCPL echivalent.)
Tema poate fi testata local astfel:
- În urma build-ului veți obține un executabil lcpl-codegen
:
./lcpl-codegen <input_file> <output_file> llvm-as <output_file> -o <output_file>.bc llvm-link <output_file>.bc runtime.bc -o <output_file>_run.bc lli <output_file>_run
output_file
- conține cod LLVM IR valid
Testarea temei de casă va folosi o serie de teste ce vor fi disponibile pe vmchecker. Modul în care este distribuit punctajul pentru această temă este următorul:
simple
(40p)advanced
(30p)complex
(10p) Arhiva trebuie sa aiba structura din arhiva de start: