teascade/c-compiler
1
1
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Compare commits

base: teascade:d3d487159a56d9ce11174a624df0b7af9ca52130
Branches Tags
teascade:main
teascade:typechecker
..
compare: teascade:226118bcbb073f3d7a2e621cc46bb8d9e5410b8f
Branches Tags
teascade:main
teascade:typechecker

No commits in common. "d3d487159a56d9ce11174a624df0b7af9ca52130" and "226118bcbb073f3d7a2e621cc46bb8d9e5410b8f" have entirely different histories.
d3d487159a ... 226118bcbb

6 changed files with 58 additions and 202 deletions
Show Stats Expand all files Collapse all files

1
CMakeLists.txt
View File

@ -25,7 +25,6 @@ add_executable(${PROJECT_NAME}
src/typechecker.cpp
src/binops.cpp
src/casting.cpp
src/stack_allocator.cpp
)
target_compile_features(${PROJECT_NAME} PRIVATE cxx_std_20)
target_compile_options(${PROJECT_NAME} PRIVATE -Wall -Weffc++ -Wextra -Wpedantic -Werror)

52
src/ast.h
View File

@ -10,7 +10,6 @@
#include "binops.h"
#include "tokens.h"
#include "typechecker.h"
#include "stack_allocator.h"
namespace AST {
class Node {
@ -25,8 +24,7 @@ namespace AST {
class Expression : public Node {
public:
Expression(token::Metadata meta) : Node{ meta } {}
virtual codegen::StackValue codegen(codegen::Builder& builder, codegen::Scope& scope, codegen::StackAllocator& allocator) = 0;
virtual void codegen_alloca(codegen::StackAllocator& allocator) = 0;
virtual codegen::StackValue codegen(codegen::Builder& builder, codegen::Scope& scope) = 0;
virtual std::shared_ptr<types::Type> get_codegen_type(codegen::Scope& scope) = 0;
virtual void typecheck_preprocess(typecheck::Scope& scope) = 0;
virtual typecheck::ExpressionType typecheck(
@ -39,8 +37,7 @@ namespace AST {
class Statement : public Node {
public:
Statement(token::Metadata meta) : Node{ meta } {}
virtual void codegen(codegen::Builder& builder, codegen::Scope& scope, codegen::StackAllocator& allocator) = 0;
virtual void codegen_alloca(codegen::StackAllocator& allocator) = 0;
virtual void codegen(codegen::Builder& builder, codegen::Scope& scope) = 0;
virtual void typecheck_preprocess(typecheck::Scope& scope) = 0;
virtual void typecheck(typecheck::State& state, typecheck::Scope& scope) = 0;
};
@ -60,8 +57,7 @@ namespace AST {
}
virtual ~IntLiteralExpression() override = default;
virtual std::string formatted() override;
virtual codegen::StackValue codegen(codegen::Builder& builder, codegen::Scope& scope, codegen::StackAllocator& allocator) override;
virtual void codegen_alloca(codegen::StackAllocator& allocator) override;
virtual codegen::StackValue codegen(codegen::Builder& builder, codegen::Scope& scope) override;
virtual std::shared_ptr<types::Type> get_codegen_type(codegen::Scope& scope) override;
virtual void typecheck_preprocess(typecheck::Scope& scope) override;
virtual typecheck::ExpressionType typecheck(
@ -79,8 +75,7 @@ namespace AST {
StringLiteralExpression(token::Metadata meta, std::string value) : Expression{ meta }, m_value{ value } {}
virtual ~StringLiteralExpression() override = default;
virtual std::string formatted() override;
virtual codegen::StackValue codegen(codegen::Builder& builder, codegen::Scope& scope, codegen::StackAllocator& allocator) override;
virtual void codegen_alloca(codegen::StackAllocator& allocator) override;
virtual codegen::StackValue codegen(codegen::Builder& builder, codegen::Scope& scope) override;
virtual std::shared_ptr<types::Type> get_codegen_type(codegen::Scope& scope) override;
virtual void typecheck_preprocess(typecheck::Scope& scope) override;
virtual typecheck::ExpressionType typecheck(
@ -98,8 +93,7 @@ namespace AST {
ValueReferenceExpression(token::Metadata meta, std::string name) : Expression{ meta }, m_name{ name } {}
virtual ~ValueReferenceExpression() override = default;
virtual std::string formatted() override;
virtual codegen::StackValue codegen(codegen::Builder& builder, codegen::Scope& scope, codegen::StackAllocator& allocator) override;
virtual void codegen_alloca(codegen::StackAllocator& allocator) override;
virtual codegen::StackValue codegen(codegen::Builder& builder, codegen::Scope& scope) override;
virtual std::shared_ptr<types::Type> get_codegen_type(codegen::Scope& scope) override;
virtual void typecheck_preprocess(typecheck::Scope& scope) override;
virtual typecheck::ExpressionType typecheck(
@ -128,8 +122,7 @@ namespace AST {
}
virtual ~BinaryOperationExpression() override = default;
virtual std::string formatted() override;
virtual codegen::StackValue codegen(codegen::Builder& builder, codegen::Scope& scope, codegen::StackAllocator& allocator) override;
virtual void codegen_alloca(codegen::StackAllocator& allocator) override;
virtual codegen::StackValue codegen(codegen::Builder& builder, codegen::Scope& scope) override;
virtual std::shared_ptr<types::Type> get_codegen_type(codegen::Scope& scope) override;
virtual void typecheck_preprocess(typecheck::Scope& scope) override;
virtual typecheck::ExpressionType typecheck(
@ -155,8 +148,7 @@ namespace AST {
}
virtual ~FunctionCallExpression() override = default;
virtual std::string formatted() override;
virtual codegen::StackValue codegen(codegen::Builder& builder, codegen::Scope& scope, codegen::StackAllocator& allocator) override;
virtual void codegen_alloca(codegen::StackAllocator& allocator) override;
virtual codegen::StackValue codegen(codegen::Builder& builder, codegen::Scope& scope) override;
virtual std::shared_ptr<types::Type> get_codegen_type(codegen::Scope& scope) override;
virtual void typecheck_preprocess(typecheck::Scope& scope) override;
virtual typecheck::ExpressionType typecheck(
@ -182,8 +174,7 @@ namespace AST {
}
virtual ~CastExpression() override = default;
virtual std::string formatted() override;
virtual codegen::StackValue codegen(codegen::Builder& builder, codegen::Scope& scope, codegen::StackAllocator& allocator) override;
virtual void codegen_alloca(codegen::StackAllocator& allocator) override;
virtual codegen::StackValue codegen(codegen::Builder& builder, codegen::Scope& scope) override;
virtual std::shared_ptr<types::Type> get_codegen_type(codegen::Scope& scope) override;
virtual void typecheck_preprocess(typecheck::Scope& scope) override;
virtual typecheck::ExpressionType typecheck(
@ -206,8 +197,7 @@ namespace AST {
}
virtual ~RefExpression() override = default;
virtual std::string formatted() override;
virtual codegen::StackValue codegen(codegen::Builder& builder, codegen::Scope& scope, codegen::StackAllocator& allocator) override;
virtual void codegen_alloca(codegen::StackAllocator& allocator) override;
virtual codegen::StackValue codegen(codegen::Builder& builder, codegen::Scope& scope) override;
virtual std::shared_ptr<types::Type> get_codegen_type(codegen::Scope& scope) override;
virtual void typecheck_preprocess(typecheck::Scope& scope) override;
virtual typecheck::ExpressionType typecheck(
@ -230,8 +220,7 @@ namespace AST {
}
virtual ~DerefExpression() override = default;
virtual std::string formatted() override;
virtual codegen::StackValue codegen(codegen::Builder& builder, codegen::Scope& scope, codegen::StackAllocator& allocator) override;
virtual void codegen_alloca(codegen::StackAllocator& allocator) override;
virtual codegen::StackValue codegen(codegen::Builder& builder, codegen::Scope& scope) override;
virtual std::shared_ptr<types::Type> get_codegen_type(codegen::Scope& scope) override;
virtual void typecheck_preprocess(typecheck::Scope& scope) override;
virtual typecheck::ExpressionType typecheck(
@ -257,8 +246,7 @@ namespace AST {
}
virtual ~IndexAccessExpression() override = default;
virtual std::string formatted() override;
virtual codegen::StackValue codegen(codegen::Builder& builder, codegen::Scope& scope, codegen::StackAllocator& allocator) override;
virtual void codegen_alloca(codegen::StackAllocator& allocator) override;
virtual codegen::StackValue codegen(codegen::Builder& builder, codegen::Scope& scope) override;
virtual std::shared_ptr<types::Type> get_codegen_type(codegen::Scope& scope) override;
virtual void typecheck_preprocess(typecheck::Scope& scope) override;
virtual typecheck::ExpressionType typecheck(
@ -284,8 +272,7 @@ namespace AST {
}
virtual ~FieldAccessExpression() override = default;
virtual std::string formatted() override;
virtual codegen::StackValue codegen(codegen::Builder& builder, codegen::Scope& scope, codegen::StackAllocator& allocator) override;
virtual void codegen_alloca(codegen::StackAllocator& allocator) override;
virtual codegen::StackValue codegen(codegen::Builder& builder, codegen::Scope& scope) override;
virtual std::shared_ptr<types::Type> get_codegen_type(codegen::Scope& scope) override;
virtual void typecheck_preprocess(typecheck::Scope& scope) override;
virtual typecheck::ExpressionType typecheck(
@ -311,8 +298,7 @@ namespace AST {
}
virtual ~ListInitializerExpression() override = default;
virtual std::string formatted() override;
virtual codegen::StackValue codegen(codegen::Builder& builder, codegen::Scope& scope, codegen::StackAllocator& allocator) override;
virtual void codegen_alloca(codegen::StackAllocator& allocator) override;
virtual codegen::StackValue codegen(codegen::Builder& builder, codegen::Scope& scope) override;
virtual std::shared_ptr<types::Type> get_codegen_type(codegen::Scope& scope) override;
virtual void typecheck_preprocess(typecheck::Scope& scope) override;
virtual typecheck::ExpressionType typecheck(
@ -332,8 +318,7 @@ namespace AST {
}
virtual ~ReturnStatement() override = default;
virtual std::string formatted() override;
virtual void codegen(codegen::Builder& builder, codegen::Scope& scope, codegen::StackAllocator& allocator) override;
virtual void codegen_alloca(codegen::StackAllocator& allocator) override;
virtual void codegen(codegen::Builder& builder, codegen::Scope& scope) override;
virtual void typecheck_preprocess(typecheck::Scope& scope) override;
virtual void typecheck(typecheck::State& state, typecheck::Scope& scope) override;
};
@ -356,8 +341,7 @@ namespace AST {
}
virtual ~InitializationStatement() override = default;
virtual std::string formatted() override;
virtual void codegen(codegen::Builder& builder, codegen::Scope& scope, codegen::StackAllocator& allocator) override;
virtual void codegen_alloca(codegen::StackAllocator& allocator) override;
virtual void codegen(codegen::Builder& builder, codegen::Scope& scope) override;
virtual void typecheck_preprocess(typecheck::Scope& scope) override;
virtual void typecheck(typecheck::State& state, typecheck::Scope& scope) override;
};
@ -371,8 +355,7 @@ namespace AST {
}
virtual ~ExpressionStatement() override = default;
virtual std::string formatted() override;
virtual void codegen(codegen::Builder& builder, codegen::Scope& scope, codegen::StackAllocator& allocator) override;
virtual void codegen_alloca(codegen::StackAllocator& allocator) override;
virtual void codegen(codegen::Builder& builder, codegen::Scope& scope) override;
virtual void typecheck_preprocess(typecheck::Scope& scope) override;
virtual void typecheck(typecheck::State& state, typecheck::Scope& scope) override;
};
@ -394,8 +377,7 @@ namespace AST {
}
virtual ~IfStatement() override = default;
virtual std::string formatted() override;
virtual void codegen(codegen::Builder& builder, codegen::Scope& scope, codegen::StackAllocator& allocator) override;
virtual void codegen_alloca(codegen::StackAllocator& allocator) override;
virtual void codegen(codegen::Builder& builder, codegen::Scope& scope) override;
virtual void typecheck_preprocess(typecheck::Scope& scope) override;
virtual void typecheck(typecheck::State& state, typecheck::Scope& scope) override;
};

87
src/codegen.cpp
View File

@ -20,7 +20,7 @@ namespace AST {
return this->m_ty;
}
codegen::StackValue IntLiteralExpression::codegen(codegen::Builder& builder, codegen::Scope& scope, codegen::StackAllocator&) {
codegen::StackValue IntLiteralExpression::codegen(codegen::Builder& builder, codegen::Scope& scope) {
auto ty = this->m_ty->codegen(builder, scope.structs);
return codegen::StackValue{
@ -38,7 +38,7 @@ namespace AST {
return std::shared_ptr<types::Type> {stack_type};
}
codegen::StackValue StringLiteralExpression::codegen(codegen::Builder& builder, codegen::Scope& scope, codegen::StackAllocator&) {
codegen::StackValue StringLiteralExpression::codegen(codegen::Builder& builder, codegen::Scope& scope) {
auto stack_type = new types::ArrayType{
std::make_shared<types::FundamentalType>(true, types::FundamentalTypeKind::Char),
static_cast<uint32_t>(this->m_value.size()) + 1,
@ -78,7 +78,7 @@ namespace AST {
}
}
codegen::StackValue ValueReferenceExpression::codegen(codegen::Builder& builder, codegen::Scope& scope, codegen::StackAllocator&) {
codegen::StackValue ValueReferenceExpression::codegen(codegen::Builder& builder, codegen::Scope& scope) {
auto value = scope.values.find(this->m_name);
if (value != scope.values.end()) {
if (scope.is_lvalue) {
@ -121,10 +121,10 @@ namespace AST {
}
}
codegen::StackValue BinaryOperationExpression::codegen(codegen::Builder& builder, codegen::Scope& scope, codegen::StackAllocator& allocator) {
codegen::StackValue BinaryOperationExpression::codegen(codegen::Builder& builder, codegen::Scope& scope) {
auto lvalued = scope.with_lvalue();
auto lhs = this->m_lhs->codegen(builder, this->m_binop == types::BinOp::Assignment ? lvalued : scope, allocator);
auto rhs = this->m_rhs->codegen(builder, scope, allocator);
auto lhs = this->m_lhs->codegen(builder, this->m_binop == types::BinOp::Assignment ? lvalued : scope);
auto rhs = this->m_rhs->codegen(builder, scope);
try {
switch (this->m_binop) {
case types::BinOp::Assignment:
@ -155,12 +155,12 @@ namespace AST {
return *fn_ty->return_type();
}
codegen::StackValue FunctionCallExpression::codegen(codegen::Builder& builder, codegen::Scope& scope, codegen::StackAllocator& allocator) {
codegen::StackValue FunctionCallExpression::codegen(codegen::Builder& builder, codegen::Scope& scope) {
std::vector<llvm::Value*> args{};
for (auto& arg : this->m_args) {
args.push_back(arg->codegen(builder, scope, allocator).value);
args.push_back(arg->codegen(builder, scope).value);
}
auto function = this->m_fn_expr->codegen(builder, scope, allocator);
auto function = this->m_fn_expr->codegen(builder, scope);
auto value = builder.builder->CreateCall(llvm::dyn_cast<llvm::FunctionType>(function.ty->codegen(builder, scope.structs)), function.value, args, "call");
return codegen::StackValue{
@ -173,12 +173,12 @@ namespace AST {
return this->m_ty;
}
codegen::StackValue CastExpression::codegen(codegen::Builder& builder, codegen::Scope& scope, codegen::StackAllocator& allocator) {
codegen::StackValue CastExpression::codegen(codegen::Builder& builder, codegen::Scope& scope) {
auto expr_ty = this->m_expr->get_codegen_type(scope);
if (expr_ty->m_kind == types::TypeKind::Array
&& this->m_ty->m_kind == types::TypeKind::Pointer) {
auto lvalued = scope.with_lvalue();
auto expr = this->m_expr->codegen(builder, lvalued, allocator);
auto expr = this->m_expr->codegen(builder, lvalued);
auto cast = types::find_cast(scope.casts, expr.ty, this->m_ty);
if (cast) {
return codegen::StackValue{
@ -191,7 +191,7 @@ namespace AST {
}
}
else {
auto expr = this->m_expr->codegen(builder, scope, allocator);
auto expr = this->m_expr->codegen(builder, scope);
auto cast = types::find_cast(scope.casts, expr.ty, this->m_ty);
if (cast) {
return codegen::StackValue{
@ -209,9 +209,9 @@ namespace AST {
};
}
codegen::StackValue RefExpression::codegen(codegen::Builder& builder, codegen::Scope& scope, codegen::StackAllocator& allocator) {
codegen::StackValue RefExpression::codegen(codegen::Builder& builder, codegen::Scope& scope) {
auto with_lvalue = scope.with_lvalue();
return this->m_expr->codegen(builder, with_lvalue, allocator);
return this->m_expr->codegen(builder, with_lvalue);
}
std::shared_ptr<types::Type> DerefExpression::get_codegen_type(codegen::Scope& scope) {
@ -225,8 +225,8 @@ namespace AST {
}
}
codegen::StackValue DerefExpression::codegen(codegen::Builder& builder, codegen::Scope& scope, codegen::StackAllocator& allocator) {
auto value = this->m_expr->codegen(builder, scope, allocator);
codegen::StackValue DerefExpression::codegen(codegen::Builder& builder, codegen::Scope& scope) {
auto value = this->m_expr->codegen(builder, scope);
if (value.ty->m_kind == types::TypeKind::Pointer) {
auto loaded = value.ty->load(builder, value.value, scope.structs);
return codegen::StackValue{
@ -255,16 +255,16 @@ namespace AST {
}
codegen::StackValue IndexAccessExpression::codegen(codegen::Builder& builder, codegen::Scope& scope, codegen::StackAllocator& allocator) {
codegen::StackValue IndexAccessExpression::codegen(codegen::Builder& builder, codegen::Scope& scope) {
auto intended_ty = this->m_expr->get_codegen_type(scope);
codegen::StackValue value;
if (intended_ty->m_kind != types::TypeKind::Pointer) {
auto lvalued = scope.with_lvalue();
value = this->m_expr->codegen(builder, lvalued, allocator);
value = this->m_expr->codegen(builder, lvalued);
}
else {
value = this->m_expr->codegen(builder, scope, allocator);
value = this->m_expr->codegen(builder, scope);
}
std::cout << intended_ty->formatted() << std::endl;
@ -339,9 +339,9 @@ namespace AST {
}
}
codegen::StackValue FieldAccessExpression::codegen(codegen::Builder& builder, codegen::Scope& scope, codegen::StackAllocator& allocator) {
codegen::StackValue FieldAccessExpression::codegen(codegen::Builder& builder, codegen::Scope& scope) {
auto lvalued = scope.with_lvalue();
auto struct_ptr = this->m_expr->codegen(builder, lvalued, allocator);
auto struct_ptr = this->m_expr->codegen(builder, lvalued);
if (struct_ptr.ty->m_kind == types::TypeKind::Pointer) {
auto ptr_ty = dynamic_cast<types::PointerType*>(struct_ptr.ty.get());
if (ptr_ty->m_inner->m_kind == types::TypeKind::Struct) {
@ -392,8 +392,8 @@ namespace AST {
return this->m_ty;
}
codegen::StackValue ListInitializerExpression::codegen(codegen::Builder& builder, codegen::Scope& scope, codegen::StackAllocator& allocator) {
auto value_ptr = allocator.pop_alloca(this->m_ty);
codegen::StackValue ListInitializerExpression::codegen(codegen::Builder& builder, codegen::Scope& scope) {
auto value_ptr = builder.builder->CreateAlloca(this->m_ty->codegen(builder, scope.structs));
if (this->m_ty->m_kind == types::TypeKind::Array) {
auto array_ty = dynamic_cast<types::ArrayType*>(this->m_ty.get());
@ -404,7 +404,7 @@ namespace AST {
indices.push_back(llvm::ConstantInt::get(builder.builder->getInt32Ty(), counter++));
auto gep = builder.builder->CreateGEP(
array_ty->m_inner->codegen(builder, scope.structs), value_ptr, indices, "GEP");
builder.builder->CreateStore(expr->codegen(builder, scope, allocator).value, gep);
builder.builder->CreateStore(expr->codegen(builder, scope).value, gep);
}
auto ptr_ty = std::shared_ptr<types::Type>{
@ -428,7 +428,7 @@ namespace AST {
struct_ty->codegen(builder, scope.structs), value_ptr, i, "struct_gep"
);
builder.builder->CreateStore(
this->m_expressions[i]->codegen(builder, scope, allocator).value, gep);
this->m_expressions[i]->codegen(builder, scope).value, gep);
}
auto ptr_ty = std::shared_ptr<types::Type>{
@ -450,34 +450,35 @@ namespace AST {
}
void ReturnStatement::codegen(codegen::Builder& builder, codegen::Scope& scope, codegen::StackAllocator& allocator) {
void ReturnStatement::codegen(codegen::Builder& builder, codegen::Scope& scope) {
if (!builder.block)
return;
builder.builder->SetInsertPoint(builder.block);
auto value = this->m_expr->codegen(builder, scope, allocator);
auto value = this->m_expr->codegen(builder, scope);
builder.builder->CreateRet(value.value);
}
void ExpressionStatement::codegen(codegen::Builder& builder, codegen::Scope& scope, codegen::StackAllocator& allocator) {
void ExpressionStatement::codegen(codegen::Builder& builder, codegen::Scope& scope) {
if (!builder.block)
return;
builder.builder->SetInsertPoint(builder.block);
this->m_expr->codegen(builder, scope, allocator);
this->m_expr->codegen(builder, scope);
}
void InitializationStatement::codegen(codegen::Builder& builder, codegen::Scope& scope, codegen::StackAllocator& allocator) {
void InitializationStatement::codegen(codegen::Builder& builder, codegen::Scope& scope) {
if (!builder.block)
return;
builder.builder->SetInsertPoint(builder.block);
if (this->m_type->m_kind == types::TypeKind::Array) {
auto ptr = allocator.pop_alloca(this->m_type);
auto raw_llvm_ty = this->m_type->codegen(builder, scope.structs);
auto ptr = builder.builder->CreateAlloca(raw_llvm_ty);
if (this->m_expr.has_value()) {
auto value = this->m_expr->get()->codegen(builder, scope, allocator);
auto value = this->m_expr->get()->codegen(builder, scope);
builder.builder->CreateStore(value.value, ptr, false);
}
@ -485,9 +486,10 @@ namespace AST {
return;
}
auto ptr = allocator.pop_alloca(this->m_type);
auto ty = this->m_type->codegen(builder, scope.structs);
auto ptr = builder.builder->CreateAlloca(ty);
if (this->m_expr.has_value()) {
auto value = this->m_expr->get()->codegen(builder, scope, allocator);
auto value = this->m_expr->get()->codegen(builder, scope);
builder.builder->CreateStore(value.value, ptr, false);
}
@ -498,13 +500,13 @@ namespace AST {
scope.values[this->m_name] = codegen::StackValue{ ptr, ptr_ty };
}
void IfStatement::codegen(codegen::Builder& builder, codegen::Scope& scope, codegen::StackAllocator& allocator) {
void IfStatement::codegen(codegen::Builder& builder, codegen::Scope& scope) {
if (!builder.block)
return;
builder.builder->SetInsertPoint(builder.block);
auto condition = this->m_condition->codegen(builder, scope, allocator);
auto condition = this->m_condition->codegen(builder, scope);
auto function = builder.block->getParent();
auto then_block = llvm::BasicBlock::Create(*builder.context, "then", function);
@ -519,13 +521,13 @@ namespace AST {
builder.block = then_block;
builder.builder->SetInsertPoint(then_block);
this->m_then->codegen(builder, scope, allocator);
this->m_then->codegen(builder, scope);
builder.builder->CreateBr(after_block);
if (else_block.has_value()) {
builder.block = *else_block;
builder.builder->SetInsertPoint(*else_block);
this->m_else->get()->codegen(builder, scope, allocator);
this->m_else->get()->codegen(builder, scope);
builder.builder->CreateBr(after_block);
}
@ -595,15 +597,8 @@ namespace AST {
}
}
codegen::StackAllocator allocator{ builder, scope.structs };
builder.builder->SetInsertPoint(BB);
for (auto& statement : *this->m_statements) {
statement->codegen_alloca(allocator);
}
for (auto& statement : *this->m_statements) {
statement->codegen(builder, inner_scope, allocator);
statement->codegen(builder, inner_scope);
}
}

92
src/stack_allocator.cpp
View File

@ -1,92 +0,0 @@
#include "stack_allocator.h"
#include "ast.h"
namespace codegen {
void StackAllocator::push_alloca(std::shared_ptr<types::Type> ty, std::string name) {
auto type = ty->codegen(this->m_builder, this->m_structs);
auto value = this->m_builder.builder->CreateAlloca(type, nullptr, name);
this->m_stack_ptrs.push_back(std::pair<llvm::Value*, std::shared_ptr<types::Type>>{ value, ty });
}
llvm::Value* StackAllocator::pop_alloca(std::shared_ptr<types::Type> ty) {
assert(this->m_stack_ptrs.size() > 0);
auto first = this->m_stack_ptrs[0];
assert(types::types_equal(first.second, ty));
this->m_stack_ptrs.erase(this->m_stack_ptrs.begin());
return first.first;
}
}
namespace AST {
void IntLiteralExpression::codegen_alloca(codegen::StackAllocator&) {
}
void StringLiteralExpression::codegen_alloca(codegen::StackAllocator&) {
}
void ValueReferenceExpression::codegen_alloca(codegen::StackAllocator&) {
}
void BinaryOperationExpression::codegen_alloca(codegen::StackAllocator& allocator) {
this->m_lhs->codegen_alloca(allocator);
this->m_rhs->codegen_alloca(allocator);
}
void FunctionCallExpression::codegen_alloca(codegen::StackAllocator& allocator) {
this->m_fn_expr->codegen_alloca(allocator);
for (auto& arg : this->m_args) {
arg->codegen_alloca(allocator);
}
}
void CastExpression::codegen_alloca(codegen::StackAllocator& allocator) {
this->m_expr->codegen_alloca(allocator);
}
void RefExpression::codegen_alloca(codegen::StackAllocator& allocator) {
this->m_expr->codegen_alloca(allocator);
}
void DerefExpression::codegen_alloca(codegen::StackAllocator& allocator) {
this->m_expr->codegen_alloca(allocator);
}
void IndexAccessExpression::codegen_alloca(codegen::StackAllocator& allocator) {
this->m_expr->codegen_alloca(allocator);
}
void FieldAccessExpression::codegen_alloca(codegen::StackAllocator& allocator) {
this->m_expr->codegen_alloca(allocator);
}
void ListInitializerExpression::codegen_alloca(codegen::StackAllocator& allocator) {
allocator.push_alloca(this->m_ty, "list");
for (auto& expr : this->m_expressions) {
expr->codegen_alloca(allocator);
}
}
void ReturnStatement::codegen_alloca(codegen::StackAllocator& allocator) {
this->m_expr->codegen_alloca(allocator);
}
void InitializationStatement::codegen_alloca(codegen::StackAllocator& allocator) {
allocator.push_alloca(this->m_type, this->m_name);
if (this->m_expr) {
(*this->m_expr)->codegen_alloca(allocator);
}
}
void ExpressionStatement::codegen_alloca(codegen::StackAllocator& allocator) {
this->m_expr->codegen_alloca(allocator);
}
void IfStatement::codegen_alloca(codegen::StackAllocator& allocator) {
this->m_condition->codegen_alloca(allocator);
this->m_then->codegen_alloca(allocator);
if (this->m_else) {
(*this->m_else)->codegen_alloca(allocator);
}
}
}

28
src/stack_allocator.h
View File

@ -1,28 +0,0 @@
#ifndef ALLOCATOR_H
#define ALLOCATOR_H
#include <vector>
#include <llvm/IR/IRBuilder.h>
#include "types.h"
#include "builder.h"
namespace codegen {
class StackAllocator {
private:
std::vector<std::pair<llvm::Value*, std::shared_ptr<types::Type>>> m_stack_ptrs;
codegen::Builder& m_builder;
codegen::TypeMap& m_structs;
public:
StackAllocator(codegen::Builder& builder, codegen::TypeMap& structs)
: m_stack_ptrs{}
, m_builder{ builder }
, m_structs{ structs } {
}
void push_alloca(std::shared_ptr<types::Type> ty, std::string name);
llvm::Value* pop_alloca(std::shared_ptr<types::Type> ty);
};
}
#endif

0
tokei
View File