wraith-lang/src/codegen.c

#include <stdio.h>
#include <stdlib.h>
#include <string.h>

#include <llvm-c/Analysis.h>
#include <llvm-c/BitWriter.h>
#include <llvm-c/Core.h>
#include <llvm-c/Object.h>
#include <llvm-c/Target.h>
#include <llvm-c/TargetMachine.h>
#include <llvm-c/Transforms/InstCombine.h>
#include <llvm-c/Transforms/PassManagerBuilder.h>
#include <llvm-c/Transforms/Scalar.h>
#include <llvm-c/Transforms/Utils.h>

#include "ast.h"

typedef struct LocalVariable
{
    char *name;
    LLVMValueRef pointer;
    LLVMValueRef value;
} LocalVariable;

typedef struct FunctionArgument
{
    char *name;
    LLVMValueRef value;
} FunctionArgument;

typedef struct ScopeFrame
{
    LocalVariable *localVariables;
    uint32_t localVariableCount;
} ScopeFrame;

typedef struct Scope
{
    ScopeFrame *scopeStack;
    uint32_t scopeStackCount;
} Scope;

Scope *scope;

typedef struct StructTypeField
{
    char *name;
    uint32_t index;
} StructTypeField;

typedef struct StructTypeFunction
{
    char *name;
    LLVMValueRef function;
    LLVMTypeRef returnType;
    uint8_t isStatic;
} StructTypeFunction;

typedef struct StructTypeDeclaration
{
    char *name;
    LLVMTypeRef structType;
    LLVMTypeRef structPointerType;
    StructTypeField *fields;
    uint32_t fieldCount;

    StructTypeFunction *functions;
    uint32_t functionCount;
} StructTypeDeclaration;

StructTypeDeclaration *structTypeDeclarations;
uint32_t structTypeDeclarationCount;

static Scope *CreateScope()
{
    Scope *scope = malloc(sizeof(Scope));

    scope->scopeStack = malloc(sizeof(ScopeFrame));
    scope->scopeStack[0].localVariableCount = 0;
    scope->scopeStack[0].localVariables = NULL;
    scope->scopeStackCount = 1;

    return scope;
}

static void PushScopeFrame(Scope *scope)
{
    uint32_t index = scope->scopeStackCount;
    scope->scopeStack = realloc(
        scope->scopeStack,
        sizeof(ScopeFrame) * (scope->scopeStackCount + 1));
    scope->scopeStack[index].localVariableCount = 0;
    scope->scopeStack[index].localVariables = NULL;

    scope->scopeStackCount += 1;
}

static void PopScopeFrame(Scope *scope)
{
    uint32_t i;
    uint32_t index = scope->scopeStackCount - 1;

    if (scope->scopeStack[index].localVariables != NULL)
    {
        for (i = 0; i < scope->scopeStack[index].localVariableCount; i += 1)
        {
            free(scope->scopeStack[index].localVariables[i].name);
        }
        free(scope->scopeStack[index].localVariables);
    }

    scope->scopeStackCount -= 1;

    scope->scopeStack =
        realloc(scope->scopeStack, sizeof(ScopeFrame) * scope->scopeStackCount);
}

static void AddLocalVariable(
    Scope *scope,
    LLVMValueRef pointer, /* can be NULL */
    LLVMValueRef value,   /* can be NULL */
    char *name)
{
    ScopeFrame *scopeFrame = &scope->scopeStack[scope->scopeStackCount - 1];
    uint32_t index = scopeFrame->localVariableCount;

    scopeFrame->localVariables = realloc(
        scopeFrame->localVariables,
        sizeof(LocalVariable) * (scopeFrame->localVariableCount + 1));
    scopeFrame->localVariables[index].name = strdup(name);
    scopeFrame->localVariables[index].pointer = pointer;
    scopeFrame->localVariables[index].value = value;

    scopeFrame->localVariableCount += 1;
}

static LLVMTypeRef WraithTypeToLLVMType(PrimitiveType type)
{
    switch (type)
    {
    case Int:
        return LLVMInt64Type();

    case UInt:
        return LLVMInt64Type();

    case Bool:
        return LLVMInt1Type();

    case Void:
        return LLVMVoidType();
    }

    fprintf(stderr, "Unrecognized type!");
    return NULL;
}

static LLVMTypeRef FindStructType(char *name)
{
    uint32_t i;

    for (i = 0; i < structTypeDeclarationCount; i += 1)
    {
        if (strcmp(structTypeDeclarations[i].name, name) == 0)
        {
            return structTypeDeclarations[i].structType;
        }
    }

    return NULL;
}

static LLVMValueRef FindStructFieldPointer(
    LLVMBuilderRef builder,
    LLVMValueRef structPointer,
    char *name)
{
    int32_t i, j;

    LLVMTypeRef structPointerType = LLVMTypeOf(structPointer);

    for (i = 0; i < structTypeDeclarationCount; i += 1)
    {
        if (structTypeDeclarations[i].structPointerType == structPointerType)
        {
            for (j = 0; j < structTypeDeclarations[i].fieldCount; j += 1)
            {
                if (strcmp(structTypeDeclarations[i].fields[j].name, name) == 0)
                {
                    char *ptrName = strdup(name);
                    strcat(ptrName, "_ptr");
                    return LLVMBuildStructGEP(
                        builder,
                        structPointer,
                        structTypeDeclarations[i].fields[j].index,
                        ptrName);
                    free(ptrName);
                }
            }
        }
    }

    printf("Failed to find struct field pointer!");
    return NULL;
}

static LLVMValueRef FindVariablePointer(char *name)
{
    int32_t i, j;

    for (i = scope->scopeStackCount - 1; i >= 0; i -= 1)
    {
        for (j = 0; j < scope->scopeStack[i].localVariableCount; j += 1)
        {
            if (strcmp(scope->scopeStack[i].localVariables[j].name, name) == 0)
            {
                return scope->scopeStack[i].localVariables[j].pointer;
            }
        }
    }

    printf("Failed to find variable pointer!");
    return NULL;
}

static LLVMValueRef FindVariableValue(LLVMBuilderRef builder, char *name)
{
    int32_t i, j;

    for (i = scope->scopeStackCount - 1; i >= 0; i -= 1)
    {
        for (j = 0; j < scope->scopeStack[i].localVariableCount; j += 1)
        {
            if (strcmp(scope->scopeStack[i].localVariables[j].name, name) == 0)
            {
                if (scope->scopeStack[i].localVariables[j].value != NULL)
                {
                    return scope->scopeStack[i].localVariables[j].value;
                }
                else
                {
                    return LLVMBuildLoad(
                        builder,
                        scope->scopeStack[i].localVariables[j].pointer,
                        name);
                }
            }
        }
    }

    printf("Failed to find variable value!");
    return NULL;
}

static void AddStructDeclaration(
    LLVMTypeRef wStructType,
    LLVMTypeRef wStructPointerType,
    char *name,
    Node **fieldDeclarations,
    uint32_t fieldDeclarationCount)
{
    uint32_t i;
    uint32_t index = structTypeDeclarationCount;
    structTypeDeclarations = realloc(
        structTypeDeclarations,
        sizeof(StructTypeDeclaration) * (structTypeDeclarationCount + 1));
    structTypeDeclarations[index].structType = wStructType;
    structTypeDeclarations[index].structPointerType = wStructPointerType;
    structTypeDeclarations[index].name = strdup(name);
    structTypeDeclarations[index].fields = NULL;
    structTypeDeclarations[index].fieldCount = 0;
    structTypeDeclarations[index].functions = NULL;
    structTypeDeclarations[index].functionCount = 0;

    for (i = 0; i < fieldDeclarationCount; i += 1)
    {
        structTypeDeclarations[index].fields = realloc(
            structTypeDeclarations[index].fields,
            sizeof(StructTypeField) *
                (structTypeDeclarations[index].fieldCount + 1));
        structTypeDeclarations[index].fields[i].name = strdup(
            fieldDeclarations[i]->declaration.identifier->identifier.name);
        structTypeDeclarations[index].fields[i].index = i;
        structTypeDeclarations[index].fieldCount += 1;
    }

    structTypeDeclarationCount += 1;
}

static void DeclareStructFunction(
    LLVMTypeRef wStructPointerType,
    LLVMValueRef function,
    LLVMTypeRef returnType,
    uint8_t isStatic,
    char *name)
{
    uint32_t i, index;

    for (i = 0; i < structTypeDeclarationCount; i += 1)
    {
        if (structTypeDeclarations[i].structPointerType == wStructPointerType)
        {
            index = structTypeDeclarations[i].functionCount;
            structTypeDeclarations[i].functions = realloc(
                structTypeDeclarations[i].functions,
                sizeof(StructTypeFunction) *
                    (structTypeDeclarations[i].functionCount + 1));
            structTypeDeclarations[i].functions[index].name = strdup(name);
            structTypeDeclarations[i].functions[index].function = function;
            structTypeDeclarations[i].functions[index].returnType = returnType;
            structTypeDeclarations[i].functions[index].isStatic = isStatic;
            structTypeDeclarations[i].functionCount += 1;

            return;
        }
    }

    fprintf(stderr, "Could not find struct type for function!\n");
}

static LLVMTypeRef LookupCustomType(char *name)
{
    uint32_t i;

    for (i = 0; i < structTypeDeclarationCount; i += 1)
    {
        if (strcmp(structTypeDeclarations[i].name, name) == 0)
        {
            return structTypeDeclarations[i].structType;
        }
    }

    fprintf(stderr, "Could not find struct type!\n");
    return NULL;
}

static LLVMTypeRef ResolveType(Node *typeNode)
{
    if (IsPrimitiveType(typeNode))
    {
        return WraithTypeToLLVMType(
            typeNode->type.typeNode->primitiveType.type);
    }
    else if (typeNode->type.typeNode->syntaxKind == CustomTypeNode)
    {
        return LookupCustomType(typeNode->type.typeNode->customType.name);
    }
    else if (typeNode->type.typeNode->syntaxKind == ReferenceTypeNode)
    {
        return LLVMPointerType(
            ResolveType(typeNode->type.typeNode->referenceType.type),
            0);
    }
    else
    {
        fprintf(stderr, "Unknown type node!\n");
        return NULL;
    }
}

static LLVMValueRef LookupFunctionByType(
    LLVMTypeRef structType,
    char *name,
    LLVMTypeRef *pReturnType,
    uint8_t *pStatic)
{
    uint32_t i, j;

    for (i = 0; i < structTypeDeclarationCount; i += 1)
    {
        if (structTypeDeclarations[i].structType == structType)
        {
            for (j = 0; j < structTypeDeclarations[i].functionCount; j += 1)
            {
                if (strcmp(structTypeDeclarations[i].functions[j].name, name) ==
                    0)
                {
                    *pReturnType =
                        structTypeDeclarations[i].functions[j].returnType;
                    *pStatic = structTypeDeclarations[i].functions[j].isStatic;
                    return structTypeDeclarations[i].functions[j].function;
                }
            }
        }
    }

    fprintf(stderr, "Could not find struct function!\n");
    return NULL;
}

static LLVMValueRef LookupFunctionByPointerType(
    LLVMTypeRef structPointerType,
    char *name,
    LLVMTypeRef *pReturnType,
    uint8_t *pStatic)
{
    uint32_t i, j;

    for (i = 0; i < structTypeDeclarationCount; i += 1)
    {
        if (structTypeDeclarations[i].structPointerType == structPointerType)
        {
            for (j = 0; j < structTypeDeclarations[i].functionCount; j += 1)
            {
                if (strcmp(structTypeDeclarations[i].functions[j].name, name) ==
                    0)
                {
                    *pReturnType =
                        structTypeDeclarations[i].functions[j].returnType;
                    *pStatic = structTypeDeclarations[i].functions[j].isStatic;
                    return structTypeDeclarations[i].functions[j].function;
                }
            }
        }
    }

    fprintf(stderr, "Could not find struct function!\n");
    return NULL;
}

static LLVMValueRef LookupFunctionByInstance(
    LLVMValueRef structPointer,
    char *name,
    LLVMTypeRef *pReturnType,
    uint8_t *pStatic)
{
    return LookupFunctionByPointerType(
        LLVMTypeOf(structPointer),
        name,
        pReturnType,
        pStatic);
}

static void AddStructVariablesToScope(
    LLVMBuilderRef builder,
    LLVMValueRef structPointer)
{
    uint32_t i, j;

    for (i = 0; i < structTypeDeclarationCount; i += 1)
    {
        if (structTypeDeclarations[i].structPointerType ==
            LLVMTypeOf(structPointer))
        {
            for (j = 0; j < structTypeDeclarations[i].fieldCount; j += 1)
            {
                char *ptrName =
                    strdup(structTypeDeclarations[i].fields[j].name);
                strcat(ptrName, "_ptr");
                LLVMValueRef elementPointer = LLVMBuildStructGEP(
                    builder,
                    structPointer,
                    structTypeDeclarations[i].fields[j].index,
                    ptrName);
                free(ptrName);

                AddLocalVariable(
                    scope,
                    elementPointer,
                    NULL,
                    structTypeDeclarations[i].fields[j].name);
            }
        }
    }
}

static LLVMValueRef CompileExpression(LLVMBuilderRef builder, Node *expression);

static LLVMValueRef CompileNumber(Node *numberExpression)
{
    return LLVMConstInt(LLVMInt64Type(), numberExpression->number.value, 0);
}

static LLVMValueRef CompileString(
    LLVMBuilderRef builder,
    Node *stringExpression)
{
    return LLVMBuildGlobalStringPtr(
        builder,
        stringExpression->stringLiteral.string,
        "stringConstant");
}

static LLVMValueRef CompileBinaryExpression(
    LLVMBuilderRef builder,
    Node *binaryExpression)
{
    LLVMValueRef left =
        CompileExpression(builder, binaryExpression->binaryExpression.left);
    LLVMValueRef right =
        CompileExpression(builder, binaryExpression->binaryExpression.right);

    switch (binaryExpression->binaryExpression.operator)
    {
    case Add:
        return LLVMBuildAdd(builder, left, right, "addResult");

    case Subtract:
        return LLVMBuildSub(builder, left, right, "subtractResult");

    case Multiply:
        return LLVMBuildMul(builder, left, right, "multiplyResult");

    /* FIXME: need type information for comparison */
    case LessThan:
        return LLVMBuildICmp(
            builder,
            LLVMIntSLT,
            left,
            right,
            "lessThanResult");

    case GreaterThan:
        return LLVMBuildICmp(
            builder,
            LLVMIntSGT,
            left,
            right,
            "greaterThanResult");

    case Mod:
        return LLVMBuildSRem(builder, left, right, "modResult");

    case Equal:
        return LLVMBuildICmp(builder, LLVMIntEQ, left, right, "equalResult");

    case LogicalOr:
        return LLVMBuildOr(builder, left, right, "orResult");
    }

    return NULL;
}

/* FIXME THIS IS ALL BROKEN */
static LLVMValueRef CompileFunctionCallExpression(
    LLVMBuilderRef builder,
    Node *functionCallExpression)
{
    uint32_t i;
    uint32_t argumentCount = 0;
    LLVMValueRef args
        [functionCallExpression->functionCallExpression.argumentSequence
             ->functionArgumentSequence.count +
         1];
    LLVMValueRef function;
    uint8_t isStatic;
    LLVMValueRef structInstance;
    LLVMTypeRef functionReturnType;
    char *returnName = "";

    /* FIXME: this needs to be recursive on access chains */
    /* FIXME: this needs to be able to call same-struct functions implicitly */
    if (functionCallExpression->functionCallExpression.identifier->syntaxKind ==
        AccessExpression)
    {
        LLVMTypeRef typeReference = FindStructType(
            functionCallExpression->functionCallExpression.identifier
                ->accessExpression.accessee->identifier.name);

        if (typeReference != NULL)
        {
            function = LookupFunctionByType(
                typeReference,
                functionCallExpression->functionCallExpression.identifier
                    ->accessExpression.accessor->identifier.name,
                &functionReturnType,
                &isStatic);
        }
        else
        {
            structInstance = FindVariablePointer(
                functionCallExpression->functionCallExpression.identifier
                    ->accessExpression.accessee->identifier.name);
            function = LookupFunctionByInstance(
                structInstance,
                functionCallExpression->functionCallExpression.identifier
                    ->accessExpression.accessor->identifier.name,
                &functionReturnType,
                &isStatic);
        }
    }
    else
    {
        fprintf(stderr, "Failed to find function!\n");
        return NULL;
    }

    if (!isStatic)
    {
        args[argumentCount] = structInstance;
        argumentCount += 1;
    }

    for (i = 0; i < functionCallExpression->functionCallExpression
                        .argumentSequence->functionArgumentSequence.count;
         i += 1)
    {
        args[argumentCount] = CompileExpression(
            builder,
            functionCallExpression->functionCallExpression.argumentSequence
                ->functionArgumentSequence.sequence[i]);
        argumentCount += 1;
    }

    if (LLVMGetTypeKind(functionReturnType) != LLVMVoidTypeKind)
    {
        returnName = "callReturn";
    }

    return LLVMBuildCall(builder, function, args, argumentCount, returnName);
}

static LLVMValueRef CompileAccessExpressionForStore(
    LLVMBuilderRef builder,
    Node *accessExpression)
{
    LLVMValueRef accesseeValue = FindVariablePointer(
        accessExpression->accessExpression.accessee->identifier.name);
    return FindStructFieldPointer(
        builder,
        accesseeValue,
        accessExpression->accessExpression.accessor->identifier.name);
}

static LLVMValueRef CompileAccessExpression(
    LLVMBuilderRef builder,
    Node *accessExpression)
{
    LLVMValueRef accesseeValue = FindVariablePointer(
        accessExpression->accessExpression.accessee->identifier.name);
    LLVMValueRef access = FindStructFieldPointer(
        builder,
        accesseeValue,
        accessExpression->accessExpression.accessor->identifier.name);
    return LLVMBuildLoad(
        builder,
        access,
        accessExpression->accessExpression.accessor->identifier.name);
}

static LLVMValueRef CompileAllocExpression(
    LLVMBuilderRef builder,
    Node *allocExpression)
{
    LLVMTypeRef type = ResolveType(allocExpression->allocExpression.type);
    return LLVMBuildMalloc(builder, type, "allocation");
}

static LLVMValueRef CompileExpression(LLVMBuilderRef builder, Node *expression)
{
    switch (expression->syntaxKind)
    {
    case AccessExpression:
        return CompileAccessExpression(builder, expression);

    case AllocExpression:
        return CompileAllocExpression(builder, expression);

    case BinaryExpression:
        return CompileBinaryExpression(builder, expression);

    case FunctionCallExpression:
        return CompileFunctionCallExpression(builder, expression);

    case Identifier:
        return FindVariableValue(builder, expression->identifier.name);

    case Number:
        return CompileNumber(expression);

    case StringLiteral:
        return CompileString(builder, expression);
    }

    fprintf(stderr, "Unknown expression kind!\n");
    return NULL;
}

static LLVMBasicBlockRef CompileStatement(
    LLVMBuilderRef builder,
    LLVMValueRef function,
    Node *statement);

static LLVMBasicBlockRef CompileReturn(
    LLVMBuilderRef builder,
    LLVMValueRef function,
    Node *returnStatemement)
{
    LLVMValueRef expression = CompileExpression(
        builder,
        returnStatemement->returnStatement.expression);
    LLVMBuildRet(builder, expression);
    return LLVMGetLastBasicBlock(function);
}

static LLVMBasicBlockRef CompileReturnVoid(
    LLVMBuilderRef builder,
    LLVMValueRef function)
{
    LLVMBuildRetVoid(builder);
    return LLVMGetLastBasicBlock(function);
}

/* FIXME: path for reference types */
static LLVMValueRef CompileFunctionVariableDeclaration(
    LLVMBuilderRef builder,
    LLVMValueRef function,
    Node *variableDeclaration)
{
    LLVMValueRef variable;
    char *variableName =
        variableDeclaration->declaration.identifier->identifier.name;
    char *ptrName = strdup(variableName);
    strcat(ptrName, "_ptr");

    variable = LLVMBuildAlloca(
        builder,
        ResolveType(variableDeclaration->declaration.type),
        ptrName);

    free(ptrName);

    AddLocalVariable(scope, variable, NULL, variableName);

    return variable;
}

static LLVMBasicBlockRef CompileAssignment(
    LLVMBuilderRef builder,
    LLVMValueRef function,
    Node *assignmentStatement)
{
    LLVMValueRef result = CompileExpression(
        builder,
        assignmentStatement->assignmentStatement.right);
    LLVMValueRef identifier;
    if (assignmentStatement->assignmentStatement.left->syntaxKind ==
        AccessExpression)
    {
        identifier = CompileAccessExpressionForStore(
            builder,
            assignmentStatement->assignmentStatement.left);
    }
    else if (
        assignmentStatement->assignmentStatement.left->syntaxKind == Identifier)
    {
        identifier = FindVariablePointer(
            assignmentStatement->assignmentStatement.left->identifier.name);
    }
    else if (
        assignmentStatement->assignmentStatement.left->syntaxKind ==
        Declaration)
    {
        identifier = CompileFunctionVariableDeclaration(
            builder,
            function,
            assignmentStatement->assignmentStatement.left);
    }
    else
    {
        printf("Identifier not found!");
        return LLVMGetLastBasicBlock(function);
    }

    LLVMBuildStore(builder, result, identifier);

    return LLVMGetLastBasicBlock(function);
}

static LLVMBasicBlockRef CompileIfStatement(
    LLVMBuilderRef builder,
    LLVMValueRef function,
    Node *ifStatement)
{
    uint32_t i;
    LLVMValueRef conditional =
        CompileExpression(builder, ifStatement->ifStatement.expression);

    LLVMBasicBlockRef block = LLVMAppendBasicBlock(function, "ifBlock");
    LLVMBasicBlockRef afterCond = LLVMAppendBasicBlock(function, "afterCond");

    LLVMBuildCondBr(builder, conditional, block, afterCond);

    LLVMPositionBuilderAtEnd(builder, block);

    for (i = 0;
         i <
         ifStatement->ifStatement.statementSequence->statementSequence.count;
         i += 1)
    {
        CompileStatement(
            builder,
            function,
            ifStatement->ifStatement.statementSequence->statementSequence
                .sequence[i]);
    }

    LLVMBuildBr(builder, afterCond);
    LLVMPositionBuilderAtEnd(builder, afterCond);

    return afterCond;
}

static LLVMBasicBlockRef CompileIfElseStatement(
    LLVMBuilderRef builder,
    LLVMValueRef function,
    Node *ifElseStatement)
{
    uint32_t i;
    LLVMValueRef conditional = CompileExpression(
        builder,
        ifElseStatement->ifElseStatement.ifStatement->ifStatement.expression);

    LLVMBasicBlockRef ifBlock = LLVMAppendBasicBlock(function, "ifBlock");
    LLVMBasicBlockRef elseBlock = LLVMAppendBasicBlock(function, "elseBlock");
    LLVMBasicBlockRef afterCond = LLVMAppendBasicBlock(function, "afterCond");

    LLVMBuildCondBr(builder, conditional, ifBlock, elseBlock);

    LLVMPositionBuilderAtEnd(builder, ifBlock);

    for (i = 0; i < ifElseStatement->ifElseStatement.ifStatement->ifStatement
                        .statementSequence->statementSequence.count;
         i += 1)
    {
        CompileStatement(
            builder,
            function,
            ifElseStatement->ifElseStatement.ifStatement->ifStatement
                .statementSequence->statementSequence.sequence[i]);
    }

    LLVMBuildBr(builder, afterCond);

    LLVMPositionBuilderAtEnd(builder, elseBlock);

    if (ifElseStatement->ifElseStatement.elseStatement->syntaxKind ==
        StatementSequence)
    {
        for (i = 0; i < ifElseStatement->ifElseStatement.elseStatement
                            ->statementSequence.count;
             i += 1)
        {
            CompileStatement(
                builder,
                function,
                ifElseStatement->ifElseStatement.elseStatement
                    ->statementSequence.sequence[i]);
        }
    }
    else
    {
        CompileStatement(
            builder,
            function,
            ifElseStatement->ifElseStatement.elseStatement);
    }

    LLVMBuildBr(builder, afterCond);
    LLVMPositionBuilderAtEnd(builder, afterCond);

    return afterCond;
}

static LLVMBasicBlockRef CompileForLoopStatement(
    LLVMBuilderRef builder,
    LLVMValueRef function,
    Node *forLoopStatement)
{
    uint32_t i;
    LLVMBasicBlockRef entryBlock = LLVMAppendBasicBlock(function, "loopEntry");
    LLVMBasicBlockRef checkBlock = LLVMAppendBasicBlock(function, "loopCheck");
    LLVMBasicBlockRef bodyBlock = LLVMAppendBasicBlock(function, "loopBody");
    LLVMBasicBlockRef afterLoopBlock =
        LLVMAppendBasicBlock(function, "afterLoop");
    char *iteratorVariableName = forLoopStatement->forLoop.declaration
                                     ->declaration.identifier->identifier.name;
    LLVMTypeRef iteratorVariableType =
        ResolveType(forLoopStatement->forLoop.declaration->declaration.type);

    PushScopeFrame(scope);

    LLVMBuildBr(builder, entryBlock);

    LLVMPositionBuilderAtEnd(builder, entryBlock);
    LLVMBuildBr(builder, checkBlock);

    LLVMPositionBuilderAtEnd(builder, checkBlock);
    LLVMValueRef iteratorValue =
        LLVMBuildPhi(builder, iteratorVariableType, iteratorVariableName);
    AddLocalVariable(scope, NULL, iteratorValue, iteratorVariableName);

    LLVMPositionBuilderAtEnd(builder, bodyBlock);
    LLVMValueRef nextValue = LLVMBuildAdd(
        builder,
        iteratorValue,
        LLVMConstInt(
            iteratorVariableType,
            1,
            0), /* FIXME: add custom increment value */
        "next");

    LLVMPositionBuilderAtEnd(builder, checkBlock);

    LLVMValueRef iteratorEndValue =
        CompileNumber(forLoopStatement->forLoop.endNumber);
    LLVMValueRef comparison = LLVMBuildICmp(
        builder,
        LLVMIntULE,
        iteratorValue,
        iteratorEndValue,
        "iteratorCompare");

    LLVMBuildCondBr(builder, comparison, bodyBlock, afterLoopBlock);

    LLVMPositionBuilderAtEnd(builder, bodyBlock);

    LLVMBasicBlockRef lastBlock;
    for (i = 0;
         i <
         forLoopStatement->forLoop.statementSequence->statementSequence.count;
         i += 1)
    {
        lastBlock = CompileStatement(
            builder,
            function,
            forLoopStatement->forLoop.statementSequence->statementSequence
                .sequence[i]);
    }

    LLVMBuildBr(builder, checkBlock);

    LLVMPositionBuilderBefore(builder, LLVMGetFirstInstruction(checkBlock));

    LLVMValueRef incomingValues[2];
    incomingValues[0] = CompileNumber(forLoopStatement->forLoop.startNumber);
    incomingValues[1] = nextValue;

    LLVMBasicBlockRef incomingBlocks[2];
    incomingBlocks[0] = entryBlock;
    incomingBlocks[1] = lastBlock;

    LLVMAddIncoming(iteratorValue, incomingValues, incomingBlocks, 2);

    LLVMPositionBuilderAtEnd(builder, afterLoopBlock);

    PopScopeFrame(scope);

    return afterLoopBlock;
}

static LLVMBasicBlockRef CompileStatement(
    LLVMBuilderRef builder,
    LLVMValueRef function,
    Node *statement)
{
    switch (statement->syntaxKind)
    {
    case Assignment:
        return CompileAssignment(builder, function, statement);

    case Declaration:
        CompileFunctionVariableDeclaration(builder, function, statement);
        return LLVMGetLastBasicBlock(function);

    case ForLoop:
        return CompileForLoopStatement(builder, function, statement);

    case FunctionCallExpression:
        CompileFunctionCallExpression(builder, statement);
        return LLVMGetLastBasicBlock(function);

    case IfStatement:
        return CompileIfStatement(builder, function, statement);

    case IfElseStatement:
        return CompileIfElseStatement(builder, function, statement);

    case Return:
        return CompileReturn(builder, function, statement);

    case ReturnVoid:
        return CompileReturnVoid(builder, function);
    }

    fprintf(stderr, "Unknown statement kind!\n");
    return NULL;
}

static void CompileFunction(
    LLVMModuleRef module,
    char *parentStructName,
    LLVMTypeRef wStructPointerType,
    Node **fieldDeclarations,
    uint32_t fieldDeclarationCount,
    Node *functionDeclaration)
{
    uint32_t i;
    uint8_t hasReturn = 0;
    uint8_t isStatic = 0;
    Node *functionSignature =
        functionDeclaration->functionDeclaration.functionSignature;
    Node *functionBody = functionDeclaration->functionDeclaration.functionBody;
    uint32_t argumentCount = functionSignature->functionSignature.arguments
                                 ->functionSignatureArguments.count;
    LLVMTypeRef paramTypes[argumentCount + 1];
    uint32_t paramIndex = 0;

    if (functionSignature->functionSignature.modifiers->functionModifiers
            .count > 0)
    {
        for (i = 0; i < functionSignature->functionSignature.modifiers
                            ->functionModifiers.count;
             i += 1)
        {
            if (functionSignature->functionSignature.modifiers
                    ->functionModifiers.sequence[i]
                    ->syntaxKind == StaticModifier)
            {
                isStatic = 1;
                break;
            }
        }
    }

    if (!isStatic)
    {
        paramTypes[paramIndex] = wStructPointerType;
        paramIndex += 1;
    }

    PushScopeFrame(scope);

    /* FIXME: should work for non-primitive types */
    for (i = 0; i < functionSignature->functionSignature.arguments
                        ->functionSignatureArguments.count;
         i += 1)
    {
        paramTypes[paramIndex] =
            ResolveType(functionSignature->functionSignature.arguments
                            ->functionSignatureArguments.sequence[i]
                            ->declaration.type);
        paramIndex += 1;
    }

    LLVMTypeRef returnType =
        ResolveType(functionSignature->functionSignature.type);
    LLVMTypeRef functionType =
        LLVMFunctionType(returnType, paramTypes, paramIndex, 0);

    char *functionName = strdup(parentStructName);
    strcat(functionName, "_");
    strcat(
        functionName,
        functionSignature->functionSignature.identifier->identifier.name);
    LLVMValueRef function = LLVMAddFunction(module, functionName, functionType);
    free(functionName);

    DeclareStructFunction(
        wStructPointerType,
        function,
        returnType,
        isStatic,
        functionSignature->functionSignature.identifier->identifier.name);

    LLVMBasicBlockRef entry = LLVMAppendBasicBlock(function, "entry");
    LLVMBuilderRef builder = LLVMCreateBuilder();
    LLVMPositionBuilderAtEnd(builder, entry);

    if (!isStatic)
    {
        LLVMValueRef wStructPointer = LLVMGetParam(function, 0);
        AddStructVariablesToScope(builder, wStructPointer);
    }

    for (i = 0; i < functionSignature->functionSignature.arguments
                        ->functionSignatureArguments.count;
         i += 1)
    {
        char *ptrName = strdup(functionSignature->functionSignature.arguments
                                   ->functionSignatureArguments.sequence[i]
                                   ->declaration.identifier->identifier.name);
        strcat(ptrName, "_ptr");
        LLVMValueRef argument = LLVMGetParam(function, i + !isStatic);
        LLVMValueRef argumentCopy =
            LLVMBuildAlloca(builder, LLVMTypeOf(argument), ptrName);
        LLVMBuildStore(builder, argument, argumentCopy);
        free(ptrName);
        AddLocalVariable(
            scope,
            argumentCopy,
            NULL,
            functionSignature->functionSignature.arguments
                ->functionSignatureArguments.sequence[i]
                ->declaration.identifier->identifier.name);
    }

    for (i = 0; i < functionBody->statementSequence.count; i += 1)
    {
        CompileStatement(
            builder,
            function,
            functionBody->statementSequence.sequence[i]);
    }

    hasReturn =
        LLVMGetBasicBlockTerminator(LLVMGetLastBasicBlock(function)) != NULL;

    if (LLVMGetTypeKind(returnType) == LLVMVoidTypeKind && !hasReturn)
    {
        LLVMBuildRetVoid(builder);
    }
    else if (LLVMGetTypeKind(returnType) != LLVMVoidTypeKind && !hasReturn)
    {
        fprintf(stderr, "Return statement not provided!");
    }

    PopScopeFrame(scope);

    LLVMDisposeBuilder(builder);
}

static void CompileStruct(
    LLVMModuleRef module,
    LLVMContextRef context,
    Node *node)
{
    uint32_t i;
    uint32_t fieldCount = 0;
    uint32_t declarationCount =
        node->structDeclaration.declarationSequence->declarationSequence.count;
    uint8_t packed = 1;
    LLVMTypeRef types[declarationCount];
    Node *currentDeclarationNode;
    Node *fieldDeclarations[declarationCount];
    char *structName = node->structDeclaration.identifier->identifier.name;

    PushScopeFrame(scope);

    LLVMTypeRef wStructType = LLVMStructCreateNamed(context, structName);
    LLVMTypeRef wStructPointerType = LLVMPointerType(
        wStructType,
        0); /* FIXME: is this address space correct? */

    /* first, build the structure definition */
    for (i = 0; i < declarationCount; i += 1)
    {
        currentDeclarationNode = node->structDeclaration.declarationSequence
                                     ->declarationSequence.sequence[i];

        switch (currentDeclarationNode->syntaxKind)
        {
        case Declaration: /* this is badly named */
            types[fieldCount] =
                ResolveType(currentDeclarationNode->declaration.type);
            fieldDeclarations[fieldCount] = currentDeclarationNode;
            fieldCount += 1;
            break;
        }
    }

    LLVMStructSetBody(wStructType, types, fieldCount, packed);
    AddStructDeclaration(
        wStructType,
        wStructPointerType,
        structName,
        fieldDeclarations,
        fieldCount);

    /* now we can wire up the functions */
    for (i = 0; i < declarationCount; i += 1)
    {
        currentDeclarationNode = node->structDeclaration.declarationSequence
                                     ->declarationSequence.sequence[i];

        switch (currentDeclarationNode->syntaxKind)
        {
        case FunctionDeclaration:
            CompileFunction(
                module,
                structName,
                wStructPointerType,
                fieldDeclarations,
                fieldCount,
                currentDeclarationNode);
            break;
        }
    }

    PopScopeFrame(scope);
}

static void Compile(
    LLVMModuleRef module,
    LLVMContextRef context,
    Node *declarationSequenceNode)
{
    uint32_t i;

    for (i = 0; i < declarationSequenceNode->declarationSequence.count; i += 1)
    {
        if (declarationSequenceNode->declarationSequence.sequence[i]
                ->syntaxKind == StructDeclaration)
        {
            CompileStruct(
                module,
                context,
                declarationSequenceNode->declarationSequence.sequence[i]);
        }
        else
        {
            fprintf(
                stderr,
                "top level declarations that are not structs are forbidden!\n");
        }
    }
}

/* TODO: move this to some kind of standard library file? */
static void RegisterLibraryFunctions(
    LLVMModuleRef module,
    LLVMContextRef context)
{
    LLVMTypeRef structType = LLVMStructCreateNamed(context, "Console");
    LLVMTypeRef structPointerType = LLVMPointerType(structType, 0);
    AddStructDeclaration(structType, structPointerType, "Console", NULL, 0);

    LLVMTypeRef printfArg = LLVMPointerType(LLVMInt8Type(), 0);
    LLVMTypeRef printfFunctionType =
        LLVMFunctionType(LLVMInt32Type(), &printfArg, 1, 1);
    LLVMValueRef printfFunction =
        LLVMAddFunction(module, "printf", printfFunctionType);
    LLVMSetLinkage(printfFunction, LLVMExternalLinkage);

    LLVMTypeRef printLineFunctionType =
        LLVMFunctionType(LLVMInt32Type(), &printfArg, 1, 1);
    LLVMValueRef printLineFunction =
        LLVMAddFunction(module, "printLine", printLineFunctionType);

    LLVMBuilderRef builder = LLVMCreateBuilder();
    LLVMBasicBlockRef entry = LLVMAppendBasicBlock(printLineFunction, "entry");
    LLVMPositionBuilderAtEnd(builder, entry);

    LLVMValueRef newLine = LLVMBuildGlobalStringPtr(builder, "\n", "newline");

    LLVMValueRef printParams[LLVMCountParams(printLineFunction)];
    LLVMGetParams(printLineFunction, printParams);
    LLVMValueRef stringPrint = LLVMBuildCall(
        builder,
        printfFunction,
        printParams,
        LLVMCountParams(printLineFunction),
        "printfCall");
    LLVMValueRef newlinePrint =
        LLVMBuildCall(builder, printfFunction, &newLine, 1, "printNewLine");
    LLVMBuildRet(
        builder,
        LLVMBuildAnd(builder, stringPrint, newlinePrint, "and"));

    DeclareStructFunction(
        structPointerType,
        printLineFunction,
        LLVMInt8Type(),
        1,
        "PrintLine");
}

int Codegen(Node *node, uint32_t optimizationLevel)
{
    scope = CreateScope();

    structTypeDeclarations = NULL;
    structTypeDeclarationCount = 0;

    LLVMModuleRef module = LLVMModuleCreateWithName("my_module");
    LLVMContextRef context = LLVMGetGlobalContext();

    RegisterLibraryFunctions(module, context);

    Compile(module, context, node);

    /* add main call */
    LLVMBuilderRef builder = LLVMCreateBuilder();

    LLVMTypeRef mainFunctionType =
        LLVMFunctionType(LLVMInt64Type(), NULL, 0, 0);
    LLVMValueRef mainFunction =
        LLVMAddFunction(module, "main", mainFunctionType);
    LLVMBasicBlockRef entry = LLVMAppendBasicBlock(mainFunction, "entry");
    LLVMPositionBuilderAtEnd(builder, entry);

    LLVMValueRef wraithMainFunction =
        LLVMGetNamedFunction(module, "Program_Main");

    LLVMValueRef mainResult =
        LLVMBuildCall(builder, wraithMainFunction, NULL, 0, "result");
    LLVMBuildRet(builder, mainResult);

    LLVMDisposeBuilder(builder);

    /* verify */
    char *error = NULL;

    if (LLVMVerifyModule(module, LLVMAbortProcessAction, &error) != 0)
    {
        fprintf(stderr, "%s\n", error);
        LLVMDisposeMessage(error);
        return EXIT_FAILURE;
    }

    /* prepare to emit assembly */
    LLVMInitializeNativeTarget();
    LLVMInitializeAllTargetInfos();
    LLVMInitializeAllTargets();
    LLVMInitializeAllTargetMCs();
    LLVMInitializeAllAsmParsers();
    LLVMInitializeAllAsmPrinters();

    LLVMSetTarget(module, LLVM_DEFAULT_TARGET_TRIPLE);
    LLVMTargetRef target;
    if (LLVMGetTargetFromTriple(LLVM_DEFAULT_TARGET_TRIPLE, &target, &error) !=
        0)
    {
        fprintf(stderr, "Failed to get target!\n");
        fprintf(stderr, "%s\n", error);
        LLVMDisposeMessage(error);
        return EXIT_FAILURE;
    }

    LLVMPassManagerRef passManager = LLVMCreatePassManager();

    LLVMPassManagerBuilderRef passManagerBuilder =
        LLVMPassManagerBuilderCreate();
    LLVMPassManagerBuilderSetOptLevel(passManagerBuilder, optimizationLevel);
    LLVMPassManagerBuilderPopulateModulePassManager(
        passManagerBuilder,
        passManager);

    LLVMRunPassManager(passManager, module);

    if (LLVMWriteBitcodeToFile(module, "test.bc") != 0)
    {
        fprintf(stderr, "error writing bitcode to file\n");
        return EXIT_FAILURE;
    }

    char *cpu = "generic";
    char *features = "";

    LLVMTargetMachineRef targetMachine = LLVMCreateTargetMachine(
        target,
        LLVM_DEFAULT_TARGET_TRIPLE,
        cpu,
        features,
        LLVMCodeGenLevelDefault,
        LLVMRelocDefault,
        LLVMCodeModelDefault);

    if (LLVMTargetMachineEmitToFile(
            targetMachine,
            module,
            "test.o",
            LLVMObjectFile,
            &error) != 0)
    {
        fprintf(stderr, "Failed to emit machine code!\n");
        fprintf(stderr, "%s\n", error);
        LLVMDisposeMessage(error);
        return EXIT_FAILURE;
    }

    LLVMDisposeMessage(error);
    LLVMDisposeTargetMachine(targetMachine);
    LLVMPassManagerBuilderDispose(passManagerBuilder);
    LLVMDisposePassManager(passManager);
    LLVMDisposeModule(module);

    return EXIT_SUCCESS;
}