1129 lines
37 KiB
C
1129 lines
37 KiB
C
#include <stdio.h>
|
|
#include <stdlib.h>
|
|
#include <string.h>
|
|
|
|
#include <llvm-c/Core.h>
|
|
#include <llvm-c/Analysis.h>
|
|
#include <llvm-c/BitWriter.h>
|
|
#include <llvm-c/Object.h>
|
|
#include <llvm-c/Transforms/PassManagerBuilder.h>
|
|
#include <llvm-c/Transforms/InstCombine.h>
|
|
#include <llvm-c/Transforms/Scalar.h>
|
|
#include <llvm-c/Transforms/Utils.h>
|
|
#include <llvm-c/TargetMachine.h>
|
|
#include <llvm-c/Target.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;
|
|
}
|