100 lines
3.3 KiB
C++
100 lines
3.3 KiB
C++
#include "definition.hpp"
|
|
#include "error.hpp"
|
|
#include "ast.hpp"
|
|
#include "instruction.hpp"
|
|
#include "llvm_context.hpp"
|
|
#include "type.hpp"
|
|
#include "type_env.hpp"
|
|
#include <llvm/IR/DerivedTypes.h>
|
|
#include <llvm/IR/Function.h>
|
|
#include <llvm/IR/Type.h>
|
|
|
|
void definition_defn::find_free(type_mgr& mgr, type_env_ptr& env) {
|
|
this->env = env;
|
|
|
|
var_env = type_scope(env);
|
|
return_type = mgr.new_type();
|
|
full_type = return_type;
|
|
|
|
for(auto it = params.rbegin(); it != params.rend(); it++) {
|
|
type_ptr param_type = mgr.new_type();
|
|
full_type = type_ptr(new type_arr(param_type, full_type));
|
|
var_env->bind(*it, param_type);
|
|
}
|
|
|
|
body->find_free(mgr, var_env, free_variables);
|
|
}
|
|
|
|
void definition_defn::insert_types(type_mgr& mgr) {
|
|
env->bind(name, full_type);
|
|
}
|
|
|
|
void definition_defn::typecheck(type_mgr& mgr) {
|
|
type_ptr body_type = body->typecheck(mgr);
|
|
mgr.unify(return_type, body_type);
|
|
}
|
|
|
|
void definition_defn::compile() {
|
|
env_ptr new_env = env_ptr(new env_offset(0, nullptr));
|
|
for(auto it = params.rbegin(); it != params.rend(); it++) {
|
|
new_env = env_ptr(new env_var(*it, new_env));
|
|
}
|
|
body->compile(new_env, instructions);
|
|
instructions.push_back(instruction_ptr(new instruction_update(params.size())));
|
|
instructions.push_back(instruction_ptr(new instruction_pop(params.size())));
|
|
}
|
|
|
|
void definition_defn::declare_llvm(llvm_context& ctx) {
|
|
generated_function = ctx.create_custom_function(name, params.size());
|
|
}
|
|
|
|
void definition_defn::generate_llvm(llvm_context& ctx) {
|
|
ctx.builder.SetInsertPoint(&generated_function->getEntryBlock());
|
|
for(auto& instruction : instructions) {
|
|
instruction->gen_llvm(ctx, generated_function);
|
|
}
|
|
ctx.builder.CreateRetVoid();
|
|
}
|
|
|
|
void definition_data::insert_types(type_mgr& mgr, type_env_ptr& env) {
|
|
this->env = env;
|
|
env->bind_type(name, type_ptr(new type_data(name)));
|
|
}
|
|
|
|
void definition_data::insert_constructors() const {
|
|
type_ptr return_type = env->lookup_type(name);
|
|
type_data* this_type = static_cast<type_data*>(return_type.get());
|
|
int next_tag = 0;
|
|
|
|
for(auto& constructor : constructors) {
|
|
constructor->tag = next_tag;
|
|
this_type->constructors[constructor->name] = { next_tag++ };
|
|
|
|
type_ptr full_type = return_type;
|
|
for(auto it = constructor->types.rbegin(); it != constructor->types.rend(); it++) {
|
|
type_ptr type = env->lookup_type(*it);
|
|
if(!type) throw 0;
|
|
full_type = type_ptr(new type_arr(type, full_type));
|
|
}
|
|
|
|
env->bind(constructor->name, full_type);
|
|
}
|
|
}
|
|
|
|
void definition_data::generate_llvm(llvm_context& ctx) {
|
|
for(auto& constructor : constructors) {
|
|
auto new_function =
|
|
ctx.create_custom_function(constructor->name, constructor->types.size());
|
|
std::vector<instruction_ptr> instructions;
|
|
instructions.push_back(instruction_ptr(
|
|
new instruction_pack(constructor->tag, constructor->types.size())
|
|
));
|
|
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();
|
|
}
|
|
}
|