#include "ast.hpp" #include #include "binop.hpp" #include "definition.hpp" #include "graph.hpp" #include "instruction.hpp" #include "llvm_context.hpp" #include "parser.hpp" #include "error.hpp" #include "type.hpp" #include "parse_driver.hpp" #include "llvm/IR/LegacyPassManager.h" #include "llvm/IR/Verifier.h" #include "llvm/Support/TargetSelect.h" #include "llvm/Support/TargetRegistry.h" #include "llvm/Support/raw_ostream.h" #include "llvm/Support/FileSystem.h" #include "llvm/Target/TargetOptions.h" #include "llvm/Target/TargetMachine.h" void yy::parser::error(const yy::location& loc, const std::string& msg) { std::cout << "An error occured: " << msg << std::endl; } void prelude_types(definition_group& defs, type_env_ptr env) { type_ptr int_type = type_ptr(new type_internal("Int")); env->bind_type("Int", int_type); type_ptr int_type_app = type_ptr(new type_app(int_type)); type_ptr bool_type = type_ptr(new type_internal("Bool")); env->bind_type("Bool", bool_type); type_ptr bool_type_app = type_ptr(new type_app(bool_type)); type_ptr binop_type = type_ptr(new type_arr( int_type_app, type_ptr(new type_arr(int_type_app, int_type_app)))); env->bind("+", binop_type, visibility::global); env->bind("-", binop_type, visibility::global); env->bind("*", binop_type, visibility::global); env->bind("/", binop_type, visibility::global); env->bind("True", bool_type_app, visibility::global); env->bind("False", bool_type_app, visibility::global); } void typecheck_program( definition_group& defs, type_mgr& mgr, type_env_ptr& env) { prelude_types(defs, env); std::set free; defs.find_free(free); defs.typecheck(mgr, env); for(auto& pair : defs.env->names) { std::cout << pair.first << ": "; pair.second.type->print(mgr, std::cout); std::cout << std::endl; } } global_scope translate_program(definition_group& group) { global_scope scope; for(auto& data : group.defs_data) { data.second->into_globals(scope); } for(auto& defn : group.defs_defn) { auto& function = defn.second->into_global(scope); function.body->env->parent->set_mangled_name(defn.first, function.name); } return scope; } void output_llvm(llvm_context& ctx, const std::string& filename) { std::string targetTriple = llvm::sys::getDefaultTargetTriple(); llvm::InitializeNativeTarget(); llvm::InitializeNativeTargetAsmParser(); llvm::InitializeNativeTargetAsmPrinter(); std::string error; const llvm::Target* target = llvm::TargetRegistry::lookupTarget(targetTriple, error); if (!target) { std::cerr << error << std::endl; } else { std::string cpu = "generic"; std::string features = ""; llvm::TargetOptions options; std::unique_ptr targetMachine( target->createTargetMachine(targetTriple, cpu, features, options, llvm::Optional())); ctx.module.setDataLayout(targetMachine->createDataLayout()); ctx.module.setTargetTriple(targetTriple); std::error_code ec; llvm::raw_fd_ostream file(filename, ec, llvm::sys::fs::F_None); if (ec) { throw std::runtime_error("failed to open object file for writing"); } else { llvm::CodeGenFileType type = llvm::CGFT_ObjectFile; llvm::legacy::PassManager pm; if (targetMachine->addPassesToEmitFile(pm, file, NULL, type)) { throw std::runtime_error("failed to add passes to pass manager"); } else { pm.run(ctx.module); file.close(); } } } } void gen_llvm_internal_op(llvm_context& ctx, binop op) { auto new_function = ctx.create_custom_function(op_action(op), 2); std::vector instructions; instructions.push_back(instruction_ptr(new instruction_push(1))); instructions.push_back(instruction_ptr(new instruction_eval())); instructions.push_back(instruction_ptr(new instruction_push(1))); instructions.push_back(instruction_ptr(new instruction_eval())); instructions.push_back(instruction_ptr(new instruction_binop(op))); instructions.push_back(instruction_ptr(new instruction_update(2))); instructions.push_back(instruction_ptr(new instruction_pop(2))); ctx.builder.SetInsertPoint(&new_function->getEntryBlock()); for(auto& instruction : instructions) { instruction->gen_llvm(ctx, new_function); } ctx.builder.CreateRetVoid(); } void gen_llvm_boolean_constructor(llvm_context& ctx, const std::string& s, bool b) { auto new_function = ctx.create_custom_function(s, 0); std::vector instructions; instructions.push_back(instruction_ptr(new instruction_pushint(b))); instructions.push_back(instruction_ptr(new instruction_update(0))); ctx.builder.SetInsertPoint(&new_function->getEntryBlock()); for(auto& instruction : instructions) { instruction->gen_llvm(ctx, new_function); } ctx.builder.CreateRetVoid(); } void gen_llvm(global_scope& scope) { llvm_context ctx; gen_llvm_internal_op(ctx, PLUS); gen_llvm_internal_op(ctx, MINUS); gen_llvm_internal_op(ctx, TIMES); gen_llvm_internal_op(ctx, DIVIDE); gen_llvm_boolean_constructor(ctx, "True", true); gen_llvm_boolean_constructor(ctx, "False", false); scope.generate_llvm(ctx); ctx.module.print(llvm::outs(), nullptr); output_llvm(ctx, "program.o"); } int main(int argc, char** argv) { if(argc != 2) { std::cerr << "please enter a file to compile." << std::endl; } parse_driver driver(argv[1]); if(!driver.run_parse()) { std::cerr << "failed to open file " << argv[1] << std::endl; exit(1); } type_mgr mgr; type_env_ptr env(new type_env); for(auto& def_defn : driver.global_defs.defs_defn) { std::cout << def_defn.second->name; for(auto& param : def_defn.second->params) std::cout << " " << param; std::cout << ":" << std::endl; def_defn.second->body->print(1, std::cout); std::cout << std::endl; } try { typecheck_program(driver.global_defs, mgr, env); global_scope scope = translate_program(driver.global_defs); scope.compile(); gen_llvm(scope); } catch(unification_error& err) { err.pretty_print(std::cerr, driver, mgr); } catch(type_error& err) { err.pretty_print(std::cerr, driver); } catch(std::runtime_error& err) { std::cerr << err.what() << std::endl; } }