În cadrul acestei teme veti implementa generarea de cod pentru limbajul LCPL.

• Deadline: Termenul limită până când se pot trimite temele fără depunctări de întârziere este joi, 17 decembrie 2015, ora 23:59. Pentru mai multe detalii, consultaţi regulamentul aferent temelor de casă.
• Colaborare: Tema va fi rezolvată individual.
• Punctare: 125p pentru implementarea completă şi corectă

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 2 şi să genereze un fisier cu cod corect LLVM IR, in cazul in care analiza semnatica nu a detectat erori, sau o lista de erori.

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. Pentru aceasta parte a temei vă veți ajuta de laboratorul 5, precum și de tutorialul de generare de cod de aici http://llvm.org/releases/3.6.0/docs/tutorial/LangImpl3.html. În cazul in care testul a trecut analiza semantică (nu s-au detectat erori), se va parcurge arborele completat și pentru fiecare nod se va genera cod LLVM IR.

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:

• Semantica și comportamentul programelor LCPL
• LLVM IR
• Suportul pentru runtime

Odată ce ați citit documentația puteți trece la implementarea generării de cod, parucrgând următorii pași:

• Emiterea constantelor globale. Şirurile de caractere din program sunt constante globale care trebuie alocate în memorie şi iniţializate de către generatorul de cod.

• Emiterea obiectelor de tip String care reprezinta numele claselor. Funcția typeName din runtime va returna unul dintre aceste obiecte.

• Emiterea informației de runtime (rtti - runtime type information). Fiecare clasă din programul de intrare va avea o informație de runtime. La crearea unui obiect nou se pasează informația de runtime a clasei către operatorul new.

• Emiterea tabelei cu adresele metodelor. In informația de runtime este inclusă si tabela de funcții virtuale. Această tabelă conține adresele tuturor metodelor dintr-o clasă, precum și pe cele ale clasei părinte.

• Emiterea codului pentru metodele de iniţializare ale claselor. LCPL permite execuţia unui cod de iniţializare pentru fiecare atribut al unei clase. Acest cod va deveni parte din metoda de iniţializare (constructor) care va fi apelată de operatorul new.

• Emiterea codului pentru fiecare metodă definită de utilizator.

• Emiterea metodei 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).

- ca anul trecut

API-ul complet pentru generarea de cod LLVM il gasiti pe site-ul oficial llvm.org

• intregi

static ConstantInt * ConstantInt::get (LLVMContext &Context, const APInt &V);

• string:

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)

• tipul functiei

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);

• declararea functiei

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

• calling convention

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)

• Biblioteca de runtime LCPL. Aceasta implementează clasele si funcțiile predefinite din LCPL. Pentru a putea folosi această bibliotecă va trebui sa înţelegeţi şi să respectaţi reprezentarea internă a obiectelor LCPL.
• O tema2 de referinta
• Un framework pentru analiza semantică și generarea de cod.

- TBD

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:

• Testele publice (80p)
  • Testele simple (40p)
  • Testele advanced (30p)
  • Testele complex (10p)
• Calitatea implementării (20p)
  • Organizarea codului sursă
  • Comentariile din cod
  • Explicațiile din README - acestea trebuie să conţină o prezentare extinsă a modului de implementare a temei şi a problemelor întâmpinate pe parcurs.

Va trebui sa implementaţi un generator de cod pentru limbajul LCPL care să producă o reprezentare intermediară LLVM. Arhitectura target a generatorului de cod va fi x86 32-bit.

Programul vostru va primi la intrare arborele sintactic (AST) în formatul de ieşire generat de tema precedentă şi va produce un fişier LLVM IR. Tema este considerată corectă dacă programul in limbaj intermediar este echivalent semantic cu programul LCPL de la intrare.

Pentru a putea rula programe LLVM IR trebuie instalat pachetul llvm.

Pentru ca generatorul de cod sa fie corect este necesar să înţelegeţi: * Comportamentul construcţiilor LCPL - descris în manualul limbajului LCPL. * Reprezentarea intermediară LLVM. * Suportul pentru runtime

Pentru realizarea temei, vă punem la dispoziţie: * O bibliotecă de runtime LCPL. Aceasta implementează clasele si funcțiile predefinite din LCPL. Pentru a putea folosi această bibliotecă va trebui sa înţelegeţi şi să respectaţi reprezentarea internă a obiectelor LCPL. * Un parser si un analizor semantic pentru LCPL. * Cod care citește arborele sintactic si construiește structurile de date de la care trebuie pornită generarea de cod.

Este recomandat dar nu obligatoriu să folosiţi sursele de mai sus.

Vă recomandăm să reveniţi la această secţiune dupa ce aţi citit secţiunea despre LLVM şi despre biblioteca de runtime LCPL.

Generatorul de cod trebuie sa execute următorii pași:

Codul generat de voi trebuie să trateze eroarea de apel de metoda pe un obiect null. Pentru a trata această eroare, inainte de a apela o metodă pe un obiect trebuie verificat dacă respectivul obiect este null. Biblioteca de runtime oferă o funcție care face această verificare.

= Pe scurt despre LLVM =

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 ' llc example.ir; clang example.ir.s lcpl_runtime.c -o example; ./example

= Testarea automată = Temele trebuiesc submise pe vmchecker . Mai multe detalii găsiți în secțiunea de upload.

= Resurse = * Exemple de cod LLVM-IR pentru testele folosite în checker * Manualul oficial al limbajului LCPL * Limbajul de asamblare LLVM * Suportul de runtime pentru LCPL * Template-ul de pornire pentru temă * Arhiva de pornire pentru rezolvarea temei. * Arhiva cu suportul de runtime pentru LCPL. * Arhiva folosita la corectarea temei.

= Bibliografie = * LLVM Tutorial . Tutorialul nu se aplica direct temei (foloseste un API C++ pentru generarea de cod), insa contine informatii si exemple utile despre cum arata un generator de cod. * Cooper K., Torczon L. - Engineering a Compiler, capitolul Code Shape, în special subcapitolele 1-4. * Aho A., Lam M., Sethi R., Ullman J. - Compilers - Principles, Techniques & Tools, capitolul Intermediate-code generation, subcapitolele 6-9.

= F A Q =

= Change Log =