codegen.hpp

Go to the documentation of this file.

 
#pragma once
#include "../parser/ast.hpp"
#include <llvm/Support/raw_ostream.h>
#include <llvm/IR/LLVMContext.h>
#include <llvm/IR/BasicBlock.h>
#include <llvm/IR/IRBuilder.h>
#include <llvm/IR/Function.h>
#include <llvm/IR/Module.h>
#include <llvm/IR/Value.h>
#include <llvm/IR/Type.h>
#include <stack>
#include <map>

class CodeGenerator {
private:
    std::string libs_path;                                                      
    std::string file_name;                                                      
    std::vector<AST::StmtPtr>& stmts;                                           
    bool is_debug;                                                              
    llvm::LLVMContext context;                                                  
    llvm::IRBuilder<> builder;                                                  
    std::unique_ptr<llvm::Module> module;                                       
    std::stack<std::map<std::string, llvm::Value*>> variables;                  
    std::map<std::string, std::vector<llvm::Function*>> functions;              
    std::stack<llvm::Type*> functions_ret_types;                                
    std::stack<std::pair<llvm::BasicBlock*, llvm::BasicBlock*>> loop_blocks;    

    struct PathPart {
        std::string name;                                                       

        enum Object {
            OBJ_MODULE,
            OBJ_CLASS,
        } object;
    };
    std::stack<PathPart> current_path;                                          
 
public:
    CodeGenerator(std::vector<AST::StmtPtr>& s, std::string lp, std::string fn, bool id) : context(), builder(context), module(std::make_unique<llvm::Module>(fn, context)), stmts(s), libs_path(lp), file_name(fn), is_debug(id) {
        variables.push({});
    }

    void generate();

    void print_ir() {
        module->print(llvm::outs(), nullptr);
    }

    std::unique_ptr<llvm::Module> get_module() {
        return std::move(module);
    }
 
private:
    void generate_stmt(AST::Stmt& stmt);

    void generate_var_decl_stmt(AST::VarDeclStmt& vds);

    void generate_var_asgn_stmt(AST::VarAsgnStmt& vas);

    void generate_func_decl_stmt(AST::FuncDeclStmt& fds);

    void generate_func_call_stmt(AST::FuncCallStmt& fcs);

    void generate_return_stmt(AST::ReturnStmt& rs);

    void generate_if_else_stmt(AST::IfElseStmt& ies);

    void generate_while_cycle_stmt(AST::WhileCycleStmt& wcs);

    void generate_do_while_cycle_stmt(AST::DoWhileCycleStmt& dwcs);

    void generate_for_cycle_stmt(AST::ForCycleStmt& fcs);

    void generate_break_stmt(AST::BreakStmt& bs);

    void generate_continue_stmt(AST::ContinueStmt& cs);

    void generate_module_stmt(AST::ModuleStmt& ms);

    void generate_use_module_stmt(AST::UseModuleStmt& ums);

    void generate_extern_stmt(AST::ExternStmt& es);

    llvm::Value *generate_expr(AST::Expr& expr);

    llvm::Value *generate_literal_expr(AST::Literal& lit);

    llvm::Value *generate_binary_expr(AST::BinaryExpr& be);
    
    llvm::Value *generate_unary_expr(AST::UnaryExpr& ue);
    
    llvm::Value *generate_var_expr(AST::VarExpr& ve);

    llvm::Value *generate_func_call_expr(AST::FuncCallExpr& fce);

    llvm::Value *generate_obj_chain_expr(AST::ChainObjects& co);

    llvm::Type *type_to_llvm(AST::Type type);

    llvm::Type *get_common_type(llvm::Type *left, llvm::Type *right);

    llvm::Value *implicitly_cast(llvm::Value *val, llvm::Type *expected_type);

    std::string get_mangled_name(std::string base_name);

    std::vector<PathPart> get_resolved_name(std::string mangled_name);
};