C-backend: don't mangle type names, fix field names, fix C unions

emillaine · emillaine · commit 0817716a83ce · 2025-06-14T22:29:10.000+03:00
diff --git a/src/ast/mangle.cpp b/src/ast/mangle.cpp
@@ -112,8 +112,7 @@ std::string cx::mangleFunctionDecl(const FunctionDecl& functionDecl) {
     } else {
         stream << cxPrefix;
         stream << 'N';
-
-        mangleIdentifier(stream, functionDecl.getModule()->getName());
+        mangleIdentifier(stream, functionDecl.module.name);
 
         if (auto* typeDecl = functionDecl.getTypeDecl()) {
             mangleIdentifier(stream, typeDecl->getName());
diff --git a/src/ast/module.h b/src/ast/module.h
@@ -126,7 +126,7 @@ struct SymbolTable {
 
 /// Container for the AST of a whole module, comprised of one or more SourceFiles.
 struct Module {
-    Module(llvm::StringRef name) : name(name) {}
+    Module(std::string&& name) : name(std::move(name)) {}
     void addSourceFile(SourceFile&& file) { sourceFiles.emplace_back(std::move(file)); }
     llvm::ArrayRef<SourceFile> getSourceFiles() const { return sourceFiles; }
     llvm::MutableArrayRef<SourceFile> getSourceFiles() { return sourceFiles; }
diff --git a/src/backend/c-backend.cpp b/src/backend/c-backend.cpp
@@ -169,7 +169,7 @@ void CGenerator::codegenExtract(const ExtractInst* inst) {
     auto name = "_extract" + std::to_string(valueSuffixCounter++);
     stream << "__auto_type " << name << " = ";
     codegenInst(inst->aggregate);
-    stream << "._" << inst->index;
+    stream << "." << inst->name;
     stream << ";\n";
     emittedValues.insert({inst, std::move(name)});
 }
@@ -311,7 +311,7 @@ void CGenerator::codegenConstGEP(const ConstGEPInst* inst) {
     auto name = "_const_get_element_ptr" + std::to_string(valueSuffixCounter++);
     stream << "__auto_type " << name << " = &";
     codegenInst(inst->pointer);
-    stream << "->_" << inst->index << ";\n";
+    stream << "->" << inst->name << ";\n";
     emittedValues.insert({inst, std::move(name)});
 }
 
@@ -389,7 +389,7 @@ const std::string& CGenerator::getBlockLabel(const BasicBlock* block) {
         return it->second;
     } else {
         auto name = block->name;
-        std::replace(name.begin(), name.end(), '.', '_');
+        llvm::replace(name, '.', '_');
         llvm::raw_string_ostream os(name);
         os << valueSuffixCounter++;
         return emittedValues.insert({block, std::move(os.str())}).first->second;
@@ -614,30 +614,29 @@ void CGenerator::codegenTypeDefinition(llvm::raw_string_ostream& stream, IRType*
     case IRTypeKind::IRStructType: {
         // Generate struct definition if this is the first time we encounter this type.
         auto* irStruct = llvm::cast<IRStructType>(type);
-        if (!alreadyEmittedTypes.contains(type)) {
+        if (!irStruct->isImportedFromC && !alreadyEmittedTypes.contains(type)) {
             alreadyEmittedTypes.insert(type);
 
             // Generate type dependencies first.
-            for (auto* elementType : irStruct->elementTypes) {
-                codegenTypeDefinition(stream, elementType);
+            for (auto& field : irStruct->fields) {
+                codegenTypeDefinition(stream, field.type);
             }
 
             stream << "\nstruct " << irStruct->mangledName << " {\n";
-            int memberIndex = 0;
-            for (auto* elementType : irStruct->elementTypes) {
+            for (auto& field : irStruct->fields) {
                 stream.indent(4);
-                codegenType(stream, elementType, true);
-                stream << " _" << (memberIndex++); // TODO: add names to IRStruct fields for clearer C code gen?
-                codegenTypeSuffix(stream, elementType, true);
+                codegenType(stream, field.type, true);
+                stream << " " << field.name;
+                codegenTypeSuffix(stream, field.type, true);
                 stream << ";\n";
             }
             stream << "};\n";
         }
         break;
     }
     case IRTypeKind::IRUnionType:
-        for (auto* elementType : llvm::cast<IRUnionType>(type)->elementTypes) {
-            codegenTypeDefinition(stream, elementType);
+        for (auto& field : llvm::cast<IRUnionType>(type)->fields) {
+            codegenTypeDefinition(stream, field.type);
         }
         break;
     }
diff --git a/src/backend/ir.cpp b/src/backend/ir.cpp
@@ -1,10 +1,12 @@
 #include "ir.h"
 #pragma warning(push, 0)
+#include <llvm/ADT/SmallString.h>
 #include <llvm/ADT/StringSet.h>
 #include <llvm/ADT/StringSwitch.h>
 #pragma warning(pop)
 #include "../ast/decl.h"
 #include "../ast/mangle.h"
+#include "../ast/module.h"
 
 using namespace cx;
 
@@ -34,21 +36,39 @@ IRType* cx::getIRType(Type astType) {
 
             if (enumDecl->hasAssociatedValues()) {
                 auto unionType = new IRUnionType{IRTypeKind::IRUnionType, {}, ""};
-                irType = new IRStructType{IRTypeKind::IRStructType, {tagType, unionType}, astType.getQualifiedTypeName(), '_' + mangleType(astType), false};
+                irType = new IRStructType{IRTypeKind::IRStructType,
+                                          {IRField{tagType, "tag"}, IRField{unionType, "union"}},
+                                          astType.getQualifiedTypeName(),
+                                          '_' + mangleType(astType),
+                                          false,
+                                          false};
                 irTypes.emplace(astType.getBase(), irType);
-                auto associatedTypes = map(enumDecl->cases, [](const EnumCase& c) { return getIRType(c.associatedType); });
-                unionType->elementTypes = std::move(associatedTypes);
+                auto associatedTypes = map(enumDecl->cases, [](const EnumCase& c) { return IRField{getIRType(c.associatedType), c.name}; });
+                unionType->fields = std::move(associatedTypes);
                 return irType;
             } else {
                 irType = tagType;
             }
-        } else if (astType.getDecl()) {
-            auto structType =
-                new IRStructType{IRTypeKind::IRStructType, {}, astType.getQualifiedTypeName(), '_' + mangleType(astType), astType.getDecl()->packed};
-            irTypes.emplace(astType.getBase(), structType);
-            auto elementTypes = map(astType.getDecl()->fields, [](const FieldDecl& f) { return getIRType(f.type); });
-            structType->elementTypes = std::move(elementTypes);
-            return structType;
+        } else if (auto decl = astType.getDecl()) {
+            if (decl->isUnion()) {
+                auto unionType = new IRUnionType{IRTypeKind::IRUnionType, {}, astType.getQualifiedTypeName()};
+                irTypes.emplace(astType.getBase(), unionType);
+                // Fields are set late to handle recursive types.
+                unionType->fields = map(decl->fields, [](const FieldDecl& f) { return IRField{getIRType(f.type), f.name}; });
+                return unionType;
+            } else {
+                bool isImportedFromC = decl->module.name.ends_with("_h");
+                auto structType = new IRStructType{IRTypeKind::IRStructType,
+                                                   {},
+                                                   astType.getQualifiedTypeName(),
+                                                   isImportedFromC ? astType.getName().str() : ('_' + mangleType(astType)),
+                                                   decl->packed,
+                                                   isImportedFromC};
+                irTypes.emplace(astType.getBase(), structType);
+                // Fields are set late to handle recursive types.
+                structType->fields = map(decl->fields, [](const FieldDecl& f) { return IRField{getIRType(f.type), f.name}; });
+                return structType;
+            }
         } else {
             llvm_unreachable(StringBuilder() << "unknown type '" << astType << "'");
         }
@@ -65,8 +85,8 @@ IRType* cx::getIRType(Type astType) {
         break;
     }
     case TypeKind::TupleType: {
-        auto elementTypes = map(astType.getTupleElements(), [](const TupleElement& e) { return getIRType(e.type); });
-        irType = new IRStructType{IRTypeKind::IRStructType, std::move(elementTypes), std::string(), std::string(), false};
+        auto fields = map(astType.getTupleElements(), [](const TupleElement& e) { return IRField{getIRType(e.type), e.name}; });
+        irType = new IRStructType{IRTypeKind::IRStructType, std::move(fields), std::string(), std::string(), false, false};
         break;
     }
     case TypeKind::FunctionType: {
@@ -114,7 +134,7 @@ IRType* Value::getType() const {
         return llvm::cast<InsertInst>(this)->aggregate->getType();
     case ValueKind::ExtractInst: {
         auto extract = llvm::cast<ExtractInst>(this);
-        return extract->aggregate->getType()->getElements()[extract->index];
+        return extract->aggregate->getType()->getFields()[extract->index].type;
     }
     case ValueKind::CallInst: {
         auto functionType = llvm::cast<CallInst>(this)->function->getType();
@@ -171,8 +191,8 @@ IRType* Value::getType() const {
         auto baseType = gep->pointer->getType()->getPointee();
         switch (baseType->kind) {
         case IRTypeKind::IRStructType:
-            ASSERT(gep->index < baseType->getElements().size());
-            return baseType->getElements()[gep->index]->getPointerTo();
+            ASSERT(gep->index < baseType->getFields().size());
+            return baseType->getFields()[gep->index].type->getPointerTo();
         case IRTypeKind::IRArrayType:
             ASSERT(gep->index < baseType->getArraySize());
             return baseType->getElementType()->getPointerTo();
@@ -605,9 +625,9 @@ IRType* IRType::getPointee() {
     return llvm::cast<IRPointerType>(this)->pointee;
 }
 
-llvm::ArrayRef<IRType*> IRType::getElements() {
-    if (isUnion()) return llvm::cast<IRUnionType>(this)->elementTypes;
-    return llvm::cast<IRStructType>(this)->elementTypes;
+llvm::ArrayRef<IRField> IRType::getFields() {
+    if (isUnion()) return llvm::cast<IRUnionType>(this)->fields;
+    return llvm::cast<IRStructType>(this)->fields;
 }
 
 llvm::StringRef IRType::getName() {
@@ -659,10 +679,10 @@ llvm::raw_ostream& cx::operator<<(llvm::raw_ostream& stream, IRType* type) {
         if (type->getName() != "") {
             return stream << type->getName();
         } else {
-            stream << "{ ";
-            for (auto& element : type->getElements()) {
-                stream << element;
-                if (&element != &type->getElements().back()) stream << ", ";
+            stream << "struct { ";
+            for (auto& field : type->getFields()) {
+                stream << field.type;
+                if (&field != &type->getFields().back()) stream << ", ";
             }
             return stream << " }";
         }
@@ -672,13 +692,9 @@ llvm::raw_ostream& cx::operator<<(llvm::raw_ostream& stream, IRType* type) {
             return stream << type->getName();
         } else {
             stream << "union { ";
-            for (auto& element : type->getElements()) {
-                if (element) { // TODO: Element type should exist for all associated values
-                    stream << element;
-                } else {
-                    stream << "void";
-                }
-                if (&element != &type->getElements().back()) stream << ", ";
+            for (auto& field : type->getFields()) {
+                stream << field.type;
+                if (&field != &type->getFields().back()) stream << ", ";
             }
             return stream << " }";
         }
@@ -714,9 +730,9 @@ bool IRType::equals(IRType* other) {
         if (!other->isStruct()) return false;
         if (getName() != other->getName()) return false;
         if (getName().empty()) {
-            if (getElements().size() != other->getElements().size()) return false;
-            for (size_t i = 0; i < getElements().size(); ++i) {
-                if (!getElements()[i]->equals(other->getElements()[i])) return false;
+            if (getFields().size() != other->getFields().size()) return false;
+            for (size_t i = 0; i < getFields().size(); ++i) {
+                if (!getFields()[i].type->equals(other->getFields()[i].type)) return false;
             }
         }
         return true;
diff --git a/src/backend/ir.h b/src/backend/ir.h
@@ -24,6 +24,7 @@ struct Function;
 struct BasicBlock;
 struct Instruction;
 struct Parameter;
+struct IRField;
 
 enum class IRTypeKind {
     IRBasicType,
@@ -52,7 +53,7 @@ struct IRType {
     bool isVoid();
     bool isNever();
     IRType* getPointee();
-    llvm::ArrayRef<IRType*> getElements();
+    llvm::ArrayRef<IRField> getFields();
     llvm::StringRef getName();
     IRType* getReturnType();
     llvm::ArrayRef<IRType*> getParamTypes();
@@ -90,17 +91,24 @@ struct IRArrayType : IRType {
     static bool classof(const IRType* t) { return t->kind == IRTypeKind::IRArrayType; }
 };
 
+struct IRField {
+    IRType* type;
+    std::string name;
+};
+
 struct IRStructType : IRType {
-    std::vector<IRType*> elementTypes;
+    std::vector<IRField> fields;
     std::string name;
     std::string mangledName;
     bool packed;
+    bool isImportedFromC;
 
     static bool classof(const IRType* t) { return t->kind == IRTypeKind::IRStructType; }
 };
 
+// TODO: combine IRUnionType to IRStructType?
 struct IRUnionType : IRType {
-    std::vector<IRType*> elementTypes;
+    std::vector<IRField> fields;
     std::string name;
 
     static bool classof(const IRType* t) { return t->kind == IRTypeKind::IRUnionType; }
diff --git a/src/backend/irgen.h b/src/backend/irgen.h
@@ -3,7 +3,7 @@
 #include <vector>
 #pragma warning(push, 0)
 #include <llvm/ADT/DenseMap.h>
-#include <llvm/ADT/StringSet.h>
+#include <llvm/ADT/Twine.h>
 #pragma warning(pop)
 #include "../ast/decl.h"
 #include "../ast/expr.h"
@@ -172,7 +172,7 @@ struct IRGenerator {
         if (pointer->getType()->getPointee()->isArrayType()) {
             ASSERT(index < pointer->getType()->getPointee()->getArraySize());
         } else {
-            ASSERT(index < pointer->getType()->getPointee()->getElements().size());
+            ASSERT(index < pointer->getType()->getPointee()->getFields().size());
         }
         return insertBlock->add(new ConstGEPInst{ValueKind::ConstGEPInst, pointer, index, expr, name.str()});
     }
diff --git a/src/backend/llvm.cpp b/src/backend/llvm.cpp
@@ -38,18 +38,18 @@ llvm::Type* LLVMGenerator::getBuiltinType(llvm::StringRef name) {
 
 llvm::Type* LLVMGenerator::getStructType(IRStructType* type) {
     if (type->name.empty()) {
-        auto elementTypes = map(type->elementTypes, [&](IRType* elementType) { return getLLVMType(elementType); });
+        auto fields = map(type->fields, [&](const IRField& field) { return getLLVMType(field.type); });
         // TODO: can these be cached to `structs` as well?
-        return llvm::StructType::get(ctx, std::move(elementTypes), type->packed);
+        return llvm::StructType::get(ctx, std::move(fields), type->packed);
     }
 
     auto it = structs.find(type);
     if (it != structs.end()) return NOTNULL(it->second);
 
     auto llvmStruct = llvm::StructType::create(ctx, type->getName());
     structs.try_emplace(type, llvmStruct);
-    auto elementTypes = map(type->elementTypes, [&](IRType* elementType) { return getLLVMType(elementType); });
-    llvmStruct->setBody(std::move(elementTypes), type->packed);
+    auto fields = map(type->fields, [&](const IRField& field) { return getLLVMType(field.type); });
+    llvmStruct->setBody(std::move(fields), type->packed);
     return llvmStruct;
 }
 
@@ -95,9 +95,8 @@ llvm::Type* LLVMGenerator::getLLVMType(IRType* type, bool* isSret) {
         structs.try_emplace(unionType, structType);
 
         unsigned maxSize = 0;
-        for (auto* field : unionType->getElements()) {
-            if (!field) continue;
-            auto size = module->getDataLayout().getTypeAllocSize(getLLVMType(field));
+        for (auto& field : unionType->getFields()) {
+            auto size = module->getDataLayout().getTypeAllocSize(getLLVMType(field.type));
             if (size > maxSize) maxSize = size;
         }
 
diff --git a/src/sema/c-import.cpp b/src/sema/c-import.cpp
@@ -464,7 +464,9 @@ bool cx::importCHeader(SourceFile& importer, ImportDecl& importDecl, Typechecker
     if (headerPath.empty()) headerPath = headerName;
     importDecl.importedHeaderPath = headerPath;
 
-    auto module = new Module(headerName);
+    std::string headerModuleName = headerName.str();
+    llvm::replace(headerModuleName, '.', '_');
+    auto module = new Module(std::move(headerModuleName));
     module->addSourceFile(SourceFile(headerPath, module));
 
     auto cToCxConverter = new CToCxConverter(*module, typechecker, targetInfo, ci.getSourceManager());
@@ -486,6 +488,6 @@ bool cx::importCHeader(SourceFile& importer, ImportDecl& importDecl, Typechecker
     }
 
     importer.addImportedModule(module);
-    Module::getAllImportedModulesMap()[module->getName()] = module;
+    Module::getAllImportedModulesMap()[headerName] = module;
     return true;
 }
diff --git a/src/sema/typecheck-expr.cpp b/src/sema/typecheck-expr.cpp
@@ -877,11 +877,11 @@ static const Match* findMatchByPredicate(llvm::ArrayRef<Match> matches, const Ca
 }
 
 static bool isStdlibDecl(const Match& match) {
-    return match.decl->getModule() && match.decl->getModule()->getName() == "std";
+    return match.decl->getModule() && match.decl->getModule()->name == "std";
 }
 
 static bool isCHeaderDecl(const Match& match) {
-    return match.decl->getModule() && match.decl->getModule()->getName().ends_with(".h");
+    return match.decl->getModule() && match.decl->getModule()->name.ends_with("_h");
 }
 
 static const Match* resolveAmbiguousOverload(llvm::ArrayRef<Match> matches, const CallExpr& call) {
diff --git a/src/sema/typecheck.cpp b/src/sema/typecheck.cpp
@@ -66,7 +66,7 @@ llvm::ErrorOr<const Module&> Typechecker::importModule(SourceFile* importer, con
         return *it->second;
     }
 
-    auto module = new Module(moduleName);
+    auto module = new Module(moduleName.str());
     std::error_code error;
 
     if (manifest) {
@@ -247,7 +247,7 @@ static Decl* findDeclInModules(llvm::StringRef name, Location location, llvm::Ar
         return decls[0];
     } else if (decls.empty()) {
         return nullptr;
-    } else if (llvm::all_of(decls, [](Decl* decl) { return decl->getModule() && decl->getModule()->getName().ends_with(".h"); })) {
+    } else if (llvm::all_of(decls, [](Decl* decl) { return decl->getModule() && decl->getModule()->name.ends_with("_h"); })) {
         // For duplicate definitions in C headers, return the last definition.
         // TODO: This should only work for declarations of the same thing.
         return decls.back(); // For duplicate definitions in C headers, return the last definition.

Original file line number	Diff line number	Diff line change
`@@ -877,11 +877,11 @@ static const Match* findMatchByPredicate(llvm::ArrayRef<Match> matches, const Ca`
`877`	`877`	`}`
`878`	`878`
`879`	`879`	`static bool isStdlibDecl(const Match& match) {`
`880`		`- return match.decl->getModule() && match.decl->getModule()->getName() == "std";`
	`880`	`+ return match.decl->getModule() && match.decl->getModule()->name == "std";`
`881`	`881`	`}`
`882`	`882`
`883`	`883`	`static bool isCHeaderDecl(const Match& match) {`
`884`		`- return match.decl->getModule() && match.decl->getModule()->getName().ends_with(".h");`
	`884`	`+ return match.decl->getModule() && match.decl->getModule()->name.ends_with("_h");`
`885`	`885`	`}`
`886`	`886`
`887`	`887`	`static const Match* resolveAmbiguousOverload(llvm::ArrayRef<Match> matches, const CallExpr& call) {`