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

Fix how arrays are managed

Browse Source
This commit is contained in:
Sofia 2026-04-16 18:32:31 +03:00
parent f0607a2310
commit 238577e9ca
5 changed files with 105 additions and 84 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

161
src/codegen.cpp
View File

@ -32,7 +32,8 @@ namespace AST {
std::shared_ptr<types::Type> StringLiteralExpression::get_codegen_type(codegen::Scope&) { std::shared_ptr<types::Type> StringLiteralExpression::get_codegen_type(codegen::Scope&) {
auto stack_type = new types::ArrayType{ auto stack_type = new types::ArrayType{
std::make_unique<types::FundamentalType>(types::FundamentalTypeKind::Char), std::make_unique<types::FundamentalType>(types::FundamentalTypeKind::Char),
static_cast<uint32_t>(this->m_value.size()) + 1 static_cast<uint32_t>(this->m_value.size()) + 1,
true
}; };
return std::shared_ptr<types::Type> {stack_type}; return std::shared_ptr<types::Type> {stack_type};
} }
@ -40,7 +41,8 @@ namespace AST {
codegen::StackValue StringLiteralExpression::codegen(codegen::Builder& builder, codegen::Scope& scope) { codegen::StackValue StringLiteralExpression::codegen(codegen::Builder& builder, codegen::Scope& scope) {
auto stack_type = new types::ArrayType{ auto stack_type = new types::ArrayType{
std::make_unique<types::FundamentalType>(types::FundamentalTypeKind::Char), std::make_unique<types::FundamentalType>(types::FundamentalTypeKind::Char),
static_cast<uint32_t>(this->m_value.size()) + 1 static_cast<uint32_t>(this->m_value.size()) + 1,
true
}; };
auto str = llvm::StringRef{ this->m_value.c_str() }; auto str = llvm::StringRef{ this->m_value.c_str() };
@ -264,58 +266,45 @@ namespace AST {
if (value.ty->m_kind == types::TypeKind::Pointer) { if (value.ty->m_kind == types::TypeKind::Pointer) {
auto ptr_ty = dynamic_cast<types::PointerType*>(value.ty.get()); auto ptr_ty = dynamic_cast<types::PointerType*>(value.ty.get());
if (ptr_ty->m_inner->m_kind == types::TypeKind::Pointer) { auto gep_value = builder.builder->CreateGEP(ptr_ty->m_inner->codegen(builder, scope.structs), value.value, idx_list, "GEP");
auto inner_ptr_ty = dynamic_cast<types::PointerType*>(ptr_ty->m_inner.get()); if (scope.is_lvalue) {
return codegen::StackValue{
auto gep_value = builder.builder->CreateGEP(inner_ptr_ty->m_inner->codegen(builder, scope.structs), value.value, idx_list, "GEP"); gep_value,
if (scope.is_lvalue) { value.ty,
return codegen::StackValue{ };
gep_value,
value.ty,
};
}
else {
auto loaded = value.ty->load(builder, gep_value, scope.structs);
return codegen::StackValue{
loaded.first,
loaded.second
};
}
}
else if (ptr_ty->m_inner->m_kind == types::TypeKind::Array) {
// Must be an array otherwise
auto arr_ty = dynamic_cast<types::ArrayType*>(ptr_ty->m_inner.get());
auto gep_value = builder.builder->CreateGEP(arr_ty->m_inner->codegen(builder, scope.structs), value.value, idx_list, "GEP");
if (scope.is_lvalue) {
return codegen::StackValue{
gep_value,
value.ty,
};
}
else {
auto inner_ptr_ty = types::PointerType{ arr_ty->m_inner };
auto loaded = inner_ptr_ty.load(builder, gep_value, scope.structs);
return codegen::StackValue{
loaded.first,
loaded.second
};
}
} }
else { else {
auto gep_value = builder.builder->CreateGEP(ptr_ty->m_inner->codegen(builder, scope.structs), value.value, idx_list, "GEP"); auto loaded = value.ty->load(builder, gep_value, scope.structs);
if (scope.is_lvalue) { return codegen::StackValue{
return codegen::StackValue{ loaded.first,
gep_value, loaded.second
value.ty, };
}; }
} }
else { else if (value.ty->m_kind == types::TypeKind::Array) {
auto loaded = value.ty->load(builder, gep_value, scope.structs); auto array_ty = dynamic_cast<types::ArrayType*>(value.ty.get());
return codegen::StackValue{ if (array_ty->m_raw) {
loaded.first, throw CompileError("Tried indexing a raw array", this->m_meta);
loaded.second }
};
} auto gep_value = builder.builder->CreateGEP(array_ty->m_inner->codegen(builder, scope.structs), value.value, idx_list, "GEP");
auto ptr_ty = std::shared_ptr<types::Type>{
new types::PointerType { array_ty->m_inner}
};
if (scope.is_lvalue) {
return codegen::StackValue{
gep_value,
ptr_ty,
};
}
else {
auto loaded = ptr_ty->load(builder, gep_value, scope.structs);
return codegen::StackValue{
loaded.first,
loaded.second
};
} }
} }
@ -476,6 +465,22 @@ namespace AST {
builder.builder->SetInsertPoint(builder.block); builder.builder->SetInsertPoint(builder.block);
if (this->m_type->m_kind == types::TypeKind::Array) {
auto array_ty = dynamic_cast<types::ArrayType*>(this->m_type.get());
if (!array_ty->m_raw) {
auto raw_ty = types::ArrayType{ array_ty->m_inner, array_ty->m_size, true };
auto raw_llvm_ty = raw_ty.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);
builder.builder->CreateStore(value.value, ptr, false);
}
scope.values[this->m_name] = codegen::StackValue{ ptr, this->m_type };
return;
}
}
auto ty = this->m_type->codegen(builder, scope.structs); auto ty = this->m_type->codegen(builder, scope.structs);
auto ptr = builder.builder->CreateAlloca(ty); auto ptr = builder.builder->CreateAlloca(ty);
if (this->m_expr.has_value()) { if (this->m_expr.has_value()) {
@ -552,32 +557,34 @@ namespace AST {
int counter = 0; int counter = 0;
for (auto& param : this->m_params) { for (auto& param : this->m_params) {
if (param.second->m_kind == types::TypeKind::Pointer) { if (param.second->m_kind == types::TypeKind::Array) {
auto ty = param_ty_ptrs[counter]; auto array_ty = dynamic_cast<types::ArrayType*>(param.second.get());
auto arg = function->getArg(counter++); if (!array_ty->m_raw) {
if (param.first) { auto ty = param_ty_ptrs[counter];
arg->setName(*param.first); auto arg = function->getArg(counter++);
inner_scope.values[*param.first] = codegen::StackValue{ if (param.first) {
arg, arg->setName(*param.first);
ty, inner_scope.values[*param.first] = codegen::StackValue{
}; arg,
ty,
};
}
continue;
} }
} }
else { builder.builder->SetInsertPoint(BB);
builder.builder->SetInsertPoint(BB); auto arg_ptr = builder.builder->CreateAlloca(param_ty_ptrs[counter]->codegen(builder, scope.structs));
auto arg_ptr = builder.builder->CreateAlloca(param_ty_ptrs[counter]->codegen(builder, scope.structs)); auto param_ty_ptr = std::shared_ptr<types::Type>{
auto param_ty_ptr = std::shared_ptr<types::Type>{ new types::PointerType { param_ty_ptrs[counter]}
new types::PointerType { param_ty_ptrs[counter]} };
auto arg = function->getArg(counter++);
builder.builder->CreateStore(arg, arg_ptr);
if (param.first) {
arg->setName(*param.first);
inner_scope.values[*param.first] = codegen::StackValue{
arg_ptr,
param_ty_ptr,
}; };
auto arg = function->getArg(counter++);
builder.builder->CreateStore(arg, arg_ptr);
if (param.first) {
arg->setName(*param.first);
inner_scope.values[*param.first] = codegen::StackValue{
arg_ptr,
param_ty_ptr,
};
}
} }
} }
@ -637,7 +644,9 @@ namespace types {
} }
llvm::Type* ArrayType::codegen(codegen::Builder& builder, codegen::TypeMap& structs) { llvm::Type* ArrayType::codegen(codegen::Builder& builder, codegen::TypeMap& structs) {
return llvm::ArrayType::get(this->m_inner->codegen(builder, structs), this->m_size); if (this->m_raw)
return llvm::ArrayType::get(this->m_inner->codegen(builder, structs), this->m_size);
return llvm::PointerType::get(*builder.context, 0);
} }
llvm::Type* StructType::codegen(codegen::Builder& builder, codegen::TypeMap& structs) { llvm::Type* StructType::codegen(codegen::Builder& builder, codegen::TypeMap& structs) {

4
src/parsing.cpp
View File

@ -392,7 +392,7 @@ namespace parsing {
auto postfix = array_postfix.unwrap(); auto postfix = array_postfix.unwrap();
if (postfix) { if (postfix) {
ty = std::shared_ptr<types::Type>{ ty = std::shared_ptr<types::Type>{
new types::ArrayType(ty, *postfix) new types::ArrayType(ty, *postfix, false)
}; };
} }
else { else {
@ -511,7 +511,7 @@ namespace parsing {
auto array_postfix = postfix.unwrap(); auto array_postfix = postfix.unwrap();
if (array_postfix) { if (array_postfix) {
param_ty = std::shared_ptr<types::Type>{ param_ty = std::shared_ptr<types::Type>{
new types::PointerType(param_ty) new types::ArrayType(param_ty, *array_postfix, false)
}; };
} }
else { else {

11
src/typechecker.cpp
View File

@ -138,7 +138,7 @@ namespace AST {
auto char_ty = std::shared_ptr<types::Type>{ auto char_ty = std::shared_ptr<types::Type>{
new types::FundamentalType{ types::FundamentalTypeKind::Char } new types::FundamentalType{ types::FundamentalTypeKind::Char }
}; };
auto ptr_ty = new types::ArrayType{ char_ty, static_cast<uint32_t>(this->m_value.size()) + 1 }; auto ptr_ty = new types::ArrayType{ char_ty, static_cast<uint32_t>(this->m_value.size()) + 1, true };
return std::shared_ptr<types::Type>{ptr_ty}; return std::shared_ptr<types::Type>{ptr_ty};
} }
@ -449,7 +449,8 @@ namespace AST {
this->m_ty = std::shared_ptr<types::Type>{ this->m_ty = std::shared_ptr<types::Type>{
new types::ArrayType{ new types::ArrayType{
array_ty->m_inner, array_ty->m_inner,
static_cast<uint32_t>(this->m_expressions.size()) static_cast<uint32_t>(this->m_expressions.size()),
true
} }
}; };
} }
@ -503,7 +504,8 @@ namespace AST {
this->m_ty = std::shared_ptr<types::Type>{ this->m_ty = std::shared_ptr<types::Type>{
new types::ArrayType{ new types::ArrayType{
std::make_shared<types::FundamentalType>(types::FundamentalTypeKind::Void), std::make_shared<types::FundamentalType>(types::FundamentalTypeKind::Void),
0 0,
true
} }
}; };
return this->m_ty; return this->m_ty;
@ -518,7 +520,8 @@ namespace AST {
this->m_ty = std::shared_ptr<types::Type>{ this->m_ty = std::shared_ptr<types::Type>{
new types::ArrayType{ new types::ArrayType{
first_expr_ty, first_expr_ty,
static_cast<uint32_t>(this->m_expressions.size()) static_cast<uint32_t>(this->m_expressions.size()),
true
} }
}; };
return this->m_ty; return this->m_ty;

5
src/types.h
View File

@ -87,9 +87,10 @@ namespace types {
public: public:
std::shared_ptr<Type> m_inner; std::shared_ptr<Type> m_inner;
uint32_t m_size; uint32_t m_size;
bool m_raw;
ArrayType(std::shared_ptr<Type> inner, uint32_t size) ArrayType(std::shared_ptr<Type> inner, uint32_t size, bool raw)
: Type(TypeKind::Array), m_inner{ std::move(inner) }, m_size{ size } { : Type(TypeKind::Array), m_inner{ std::move(inner) }, m_size{ size }, m_raw{ raw } {
} }
virtual ~ArrayType() override = default; virtual ~ArrayType() override = default;
virtual std::string formatted() override; virtual std::string formatted() override;

8
test.c
View File

@ -20,6 +20,10 @@ struct Otus {
int field; int field;
}; };
void update_ptr(char* ptr) {
*ptr = 50;
}
int main() { int main() {
char text[29] = "10th fibonacci number is %d!"; char text[29] = "10th fibonacci number is %d!";
printf(text, fibonacci(10)); printf(text, fibonacci(10));
@ -35,5 +39,9 @@ int main() {
printf(" first field: %d!", otus.field); printf(" first field: %d!", otus.field);
char hello = 10;
update_ptr(&hello);
printf(" hello: %d!", hello);
return 0; return 0;
} }