2342 lines
70 KiB
C
2342 lines
70 KiB
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"
|
|
#include "util.h"
|
|
|
|
typedef struct LocalVariable
|
|
{
|
|
char *name;
|
|
LLVMValueRef pointer;
|
|
LLVMValueRef value;
|
|
} LocalVariable;
|
|
|
|
typedef struct LocalGenericType
|
|
{
|
|
char *name;
|
|
TypeTag *concreteTypeTag;
|
|
LLVMTypeRef type;
|
|
} LocalGenericType;
|
|
|
|
typedef struct FunctionArgument
|
|
{
|
|
char *name;
|
|
LLVMValueRef value;
|
|
} FunctionArgument;
|
|
|
|
typedef struct ScopeFrame
|
|
{
|
|
LocalVariable *localVariables;
|
|
uint32_t localVariableCount;
|
|
|
|
LocalGenericType *genericTypes;
|
|
uint32_t genericTypeCount;
|
|
} 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 MonomorphizedGenericFunctionHashEntry
|
|
{
|
|
uint64_t key;
|
|
TypeTag **types;
|
|
uint32_t typeCount;
|
|
StructTypeFunction function;
|
|
} MonomorphizedGenericFunctionHashEntry;
|
|
|
|
typedef struct MonomorphizedGenericFunctionHashArray
|
|
{
|
|
MonomorphizedGenericFunctionHashEntry *elements;
|
|
uint32_t count;
|
|
} MonomorphizedGenericFunctionHashArray;
|
|
|
|
#define NUM_MONOMORPHIZED_HASH_BUCKETS 1031
|
|
|
|
typedef struct StructTypeDeclaration StructTypeDeclaration;
|
|
|
|
typedef struct StructTypeGenericFunction
|
|
{
|
|
StructTypeDeclaration *parentStruct;
|
|
char *name;
|
|
Node *functionDeclarationNode;
|
|
uint8_t isStatic;
|
|
MonomorphizedGenericFunctionHashArray
|
|
monomorphizedFunctions[NUM_MONOMORPHIZED_HASH_BUCKETS];
|
|
} StructTypeGenericFunction;
|
|
|
|
struct StructTypeDeclaration
|
|
{
|
|
LLVMModuleRef module;
|
|
char *name;
|
|
LLVMTypeRef structType;
|
|
LLVMTypeRef structPointerType;
|
|
StructTypeField *fields;
|
|
uint32_t fieldCount;
|
|
|
|
StructTypeFunction *functions;
|
|
uint32_t functionCount;
|
|
|
|
StructTypeGenericFunction *genericFunctions;
|
|
uint32_t genericFunctionCount;
|
|
};
|
|
|
|
StructTypeDeclaration *structTypeDeclarations;
|
|
uint32_t structTypeDeclarationCount;
|
|
|
|
typedef struct MonomorphizedGenericStructHashEntry
|
|
{
|
|
uint64_t key;
|
|
TypeTag **types;
|
|
uint32_t typeCount;
|
|
StructTypeDeclaration *structDeclaration;
|
|
} MonomorphizedGenericStructHashEntry;
|
|
|
|
typedef struct MonomorphizedGenericStructHashArray
|
|
{
|
|
MonomorphizedGenericStructHashEntry *elements;
|
|
uint32_t count;
|
|
} MonomorphizedGenericStructHashArray;
|
|
|
|
typedef struct GenericStructTypeDeclaration
|
|
{
|
|
LLVMModuleRef module;
|
|
Node *structDeclarationNode;
|
|
MonomorphizedGenericStructHashArray
|
|
monomorphizedStructs[NUM_MONOMORPHIZED_HASH_BUCKETS];
|
|
} GenericStructTypeDeclaration;
|
|
|
|
GenericStructTypeDeclaration *genericStructTypeDeclarations;
|
|
uint32_t genericStructTypeDeclarationCount;
|
|
|
|
typedef struct SystemFunction
|
|
{
|
|
char *name;
|
|
LLVMTypeRef functionType;
|
|
LLVMValueRef function;
|
|
} SystemFunction;
|
|
|
|
SystemFunction *systemFunctions;
|
|
uint32_t systemFunctionCount;
|
|
|
|
/* FUNCTION FORWARD DECLARATIONS */
|
|
static LLVMBasicBlockRef CompileStatement(
|
|
StructTypeDeclaration *structTypeDeclaration,
|
|
LLVMBuilderRef builder,
|
|
LLVMValueRef function,
|
|
Node *statement);
|
|
|
|
static LLVMValueRef CompileExpression(
|
|
StructTypeDeclaration *structTypeDeclaration,
|
|
LLVMBuilderRef builder,
|
|
Node *expression);
|
|
|
|
static void CompileFunction(
|
|
StructTypeDeclaration *structTypeDeclaration,
|
|
Node *functionDeclaration);
|
|
|
|
static LLVMTypeRef ResolveType(TypeTag *typeTag);
|
|
|
|
static Scope *CreateScope()
|
|
{
|
|
Scope *scope = malloc(sizeof(Scope));
|
|
|
|
scope->scopeStack = malloc(sizeof(ScopeFrame));
|
|
scope->scopeStack[0].localVariableCount = 0;
|
|
scope->scopeStack[0].localVariables = NULL;
|
|
scope->scopeStack[0].genericTypeCount = 0;
|
|
scope->scopeStack[0].genericTypes = 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->scopeStack[index].genericTypeCount = 0;
|
|
scope->scopeStack[index].genericTypes = 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);
|
|
}
|
|
|
|
if (scope->scopeStack[index].genericTypes != NULL)
|
|
{
|
|
for (i = 0; i < scope->scopeStack[index].genericTypeCount; i += 1)
|
|
{
|
|
free(scope->scopeStack[index].genericTypes[i].name);
|
|
}
|
|
free(scope->scopeStack[index].genericTypes);
|
|
}
|
|
|
|
scope->scopeStackCount -= 1;
|
|
|
|
scope->scopeStack =
|
|
realloc(scope->scopeStack, sizeof(ScopeFrame) * scope->scopeStackCount);
|
|
}
|
|
|
|
static inline uint64_t HashTypeTags(TypeTag **tags, uint32_t count)
|
|
{
|
|
const uint64_t HASH_FACTOR = 97;
|
|
uint64_t result = 1;
|
|
uint32_t i;
|
|
|
|
for (i = 0; i < count; i += 1)
|
|
{
|
|
result *= HASH_FACTOR + str_hash(TypeTagToString(tags[i]));
|
|
}
|
|
|
|
return result;
|
|
}
|
|
|
|
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 void AddGenericVariable(Scope *scope, TypeTag *typeTag, char *name)
|
|
{
|
|
ScopeFrame *scopeFrame = &scope->scopeStack[scope->scopeStackCount - 1];
|
|
uint32_t index = scopeFrame->genericTypeCount;
|
|
|
|
scopeFrame->genericTypes = realloc(
|
|
scopeFrame->genericTypes,
|
|
sizeof(LocalGenericType) * (scopeFrame->genericTypeCount + 1));
|
|
scopeFrame->genericTypes[index].name = strdup(name);
|
|
scopeFrame->genericTypes[index].concreteTypeTag = typeTag;
|
|
scopeFrame->genericTypes[index].type = ResolveType(typeTag);
|
|
|
|
scopeFrame->genericTypeCount += 1;
|
|
}
|
|
|
|
static void AddStructVariablesToScope(
|
|
StructTypeDeclaration *structTypeDeclaration,
|
|
LLVMBuilderRef builder,
|
|
LLVMValueRef structPointer)
|
|
{
|
|
uint32_t i;
|
|
|
|
for (i = 0; i < structTypeDeclaration->fieldCount; i += 1)
|
|
{
|
|
char *ptrName = strdup(structTypeDeclaration->fields[i].name);
|
|
strcat(ptrName, "_ptr"); /* FIXME: needs to be realloc'd */
|
|
LLVMValueRef elementPointer = LLVMBuildStructGEP(
|
|
builder,
|
|
structPointer,
|
|
structTypeDeclaration->fields[i].index,
|
|
ptrName);
|
|
free(ptrName);
|
|
|
|
AddLocalVariable(
|
|
scope,
|
|
elementPointer,
|
|
NULL,
|
|
structTypeDeclaration->fields[i].name);
|
|
}
|
|
}
|
|
|
|
static void AddFieldToStructDeclaration(
|
|
StructTypeDeclaration *structTypeDeclaration,
|
|
char *name)
|
|
{
|
|
structTypeDeclaration->fields = realloc(
|
|
structTypeDeclaration->fields,
|
|
sizeof(StructTypeField) * (structTypeDeclaration->fieldCount + 1));
|
|
structTypeDeclaration->fields[structTypeDeclaration->fieldCount].name =
|
|
strdup(name);
|
|
structTypeDeclaration->fields[structTypeDeclaration->fieldCount].index =
|
|
structTypeDeclaration->fieldCount;
|
|
structTypeDeclaration->fieldCount += 1;
|
|
}
|
|
|
|
static void AddGenericStructDeclaration(
|
|
LLVMModuleRef module,
|
|
Node *structDeclarationNode)
|
|
{
|
|
uint32_t i;
|
|
|
|
genericStructTypeDeclarations = realloc(
|
|
genericStructTypeDeclarations,
|
|
sizeof(GenericStructTypeDeclaration) *
|
|
(genericStructTypeDeclarationCount + 1));
|
|
genericStructTypeDeclarations[genericStructTypeDeclarationCount]
|
|
.structDeclarationNode = structDeclarationNode;
|
|
genericStructTypeDeclarations[genericStructTypeDeclarationCount].module =
|
|
module;
|
|
|
|
for (i = 0; i < NUM_MONOMORPHIZED_HASH_BUCKETS; i += 1)
|
|
{
|
|
genericStructTypeDeclarations[genericStructTypeDeclarationCount]
|
|
.monomorphizedStructs[i]
|
|
.elements = NULL;
|
|
genericStructTypeDeclarations[genericStructTypeDeclarationCount]
|
|
.monomorphizedStructs[i]
|
|
.count = 0;
|
|
}
|
|
|
|
genericStructTypeDeclarationCount += 1;
|
|
}
|
|
|
|
static LLVMTypeRef WraithTypeToLLVMType(PrimitiveType type)
|
|
{
|
|
switch (type)
|
|
{
|
|
case Int:
|
|
return LLVMInt64Type();
|
|
|
|
case UInt:
|
|
return LLVMInt64Type();
|
|
|
|
case Bool:
|
|
return LLVMInt1Type();
|
|
|
|
case MemoryAddress:
|
|
return LLVMInt64Type();
|
|
|
|
case Void:
|
|
return LLVMVoidType();
|
|
}
|
|
|
|
fprintf(stderr, "Unrecognized type!");
|
|
return NULL;
|
|
}
|
|
|
|
static LocalGenericType *LookupGenericType(char *name)
|
|
{
|
|
int32_t i, j;
|
|
|
|
for (i = scope->scopeStackCount - 1; i >= 0; i -= 1)
|
|
{
|
|
for (j = 0; j < scope->scopeStack[i].genericTypeCount; j += 1)
|
|
{
|
|
if (strcmp(scope->scopeStack[i].genericTypes[j].name, name) == 0)
|
|
{
|
|
return &scope->scopeStack[i].genericTypes[j];
|
|
}
|
|
}
|
|
}
|
|
|
|
fprintf(stderr, "Could not find resolved generic type!\n");
|
|
return NULL;
|
|
}
|
|
|
|
static TypeTag *ConcretizeType(TypeTag *type)
|
|
{
|
|
if (type->type == Generic)
|
|
{
|
|
return LookupGenericType(type->value.genericType)->concreteTypeTag;
|
|
}
|
|
|
|
return type;
|
|
}
|
|
|
|
static LLVMTypeRef LookupCustomType(char *name)
|
|
{
|
|
int32_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 custom type!\n");
|
|
return NULL;
|
|
}
|
|
|
|
static StructTypeDeclaration *AddStructDeclaration(
|
|
LLVMModuleRef module,
|
|
LLVMTypeRef wStructType,
|
|
LLVMTypeRef wStructPointerType,
|
|
char *name)
|
|
{
|
|
uint32_t index = structTypeDeclarationCount;
|
|
structTypeDeclarations = realloc(
|
|
structTypeDeclarations,
|
|
sizeof(StructTypeDeclaration) * (structTypeDeclarationCount + 1));
|
|
structTypeDeclarations[index].module = module;
|
|
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;
|
|
structTypeDeclarations[index].genericFunctions = NULL;
|
|
structTypeDeclarations[index].genericFunctionCount = 0;
|
|
|
|
structTypeDeclarationCount += 1;
|
|
|
|
return &structTypeDeclarations[index];
|
|
}
|
|
|
|
static StructTypeDeclaration *CompileMonomorphizedGenericStruct(
|
|
GenericStructTypeDeclaration *genericStructTypeDeclaration,
|
|
TypeTag **genericArgumentTypes,
|
|
uint32_t genericArgumentTypeCount)
|
|
{
|
|
uint32_t i = 0;
|
|
uint32_t nameLen;
|
|
uint32_t fieldCount = 0;
|
|
Node *structDeclarationNode =
|
|
genericStructTypeDeclaration->structDeclarationNode;
|
|
uint32_t declarationCount =
|
|
structDeclarationNode->structDeclaration.declarationSequence
|
|
->declarationSequence.count;
|
|
LLVMTypeRef types[declarationCount];
|
|
|
|
PushScopeFrame(scope);
|
|
|
|
for (i = 0; i < genericArgumentTypeCount; i += 1)
|
|
{
|
|
AddGenericVariable(
|
|
scope,
|
|
genericArgumentTypes[i],
|
|
structDeclarationNode->structDeclaration.genericDeclarations
|
|
->genericDeclarations.declarations[i]
|
|
->genericDeclaration.identifier->identifier.name);
|
|
}
|
|
|
|
char *structName = strdup(
|
|
structDeclarationNode->structDeclaration.identifier->identifier.name);
|
|
nameLen = strlen(structName);
|
|
|
|
for (i = 0; i < genericArgumentTypeCount; i += 1)
|
|
{
|
|
char *inner = TypeTagToString(genericArgumentTypes[i]);
|
|
nameLen += 2 + strlen(inner);
|
|
structName = realloc(structName, sizeof(char) * nameLen);
|
|
strcat(structName, "_");
|
|
strcat(structName, inner);
|
|
}
|
|
|
|
LLVMContextRef context =
|
|
LLVMGetGlobalContext(); /* FIXME: should we pass a context? */
|
|
LLVMTypeRef wStructType = LLVMStructCreateNamed(context, structName);
|
|
LLVMTypeRef wStructPointerType = LLVMPointerType(wStructType, 0);
|
|
|
|
StructTypeDeclaration *declaration = AddStructDeclaration(
|
|
genericStructTypeDeclaration->module,
|
|
wStructType,
|
|
wStructPointerType,
|
|
structName);
|
|
|
|
/* first build the structure def */
|
|
for (i = 0; i < declarationCount; i += 1)
|
|
{
|
|
switch (structDeclarationNode->structDeclaration.declarationSequence
|
|
->declarationSequence.sequence[i]
|
|
->syntaxKind)
|
|
{
|
|
case Declaration:
|
|
types[fieldCount] = ResolveType(
|
|
structDeclarationNode->structDeclaration.declarationSequence
|
|
->declarationSequence.sequence[i]
|
|
->declaration.identifier->typeTag);
|
|
AddFieldToStructDeclaration(
|
|
declaration,
|
|
structDeclarationNode->structDeclaration.declarationSequence
|
|
->declarationSequence.sequence[i]
|
|
->declaration.identifier->identifier.name);
|
|
fieldCount += 1;
|
|
break;
|
|
}
|
|
}
|
|
|
|
LLVMStructSetBody(wStructType, types, fieldCount, 1);
|
|
|
|
/* now we wire up the functions */
|
|
for (i = 0; i < declarationCount; i += 1)
|
|
{
|
|
switch (structDeclarationNode->structDeclaration.declarationSequence
|
|
->declarationSequence.sequence[i]
|
|
->syntaxKind)
|
|
{
|
|
case FunctionDeclaration:
|
|
CompileFunction(
|
|
declaration,
|
|
structDeclarationNode->structDeclaration.declarationSequence
|
|
->declarationSequence.sequence[i]);
|
|
break;
|
|
}
|
|
}
|
|
|
|
PopScopeFrame(scope);
|
|
|
|
return declaration;
|
|
}
|
|
|
|
static StructTypeDeclaration *LookupGenericStructType(
|
|
ConcreteGenericTypeTag *typeTag)
|
|
{
|
|
uint32_t i, j, k;
|
|
uint64_t typeHash;
|
|
uint8_t match;
|
|
TypeTag *genericTypeTags[typeTag->genericArgumentCount];
|
|
|
|
for (i = 0; i < typeTag->genericArgumentCount; i += 1)
|
|
{
|
|
genericTypeTags[i] = ConcretizeType(typeTag->genericArguments[i]);
|
|
}
|
|
|
|
for (i = 0; i < genericStructTypeDeclarationCount; i += 1)
|
|
{
|
|
if (strcmp(
|
|
genericStructTypeDeclarations[i]
|
|
.structDeclarationNode->structDeclaration.identifier
|
|
->identifier.name,
|
|
typeTag->name) == 0)
|
|
{
|
|
typeHash =
|
|
HashTypeTags(genericTypeTags, typeTag->genericArgumentCount);
|
|
|
|
MonomorphizedGenericStructHashArray *hashArray =
|
|
&genericStructTypeDeclarations[i].monomorphizedStructs
|
|
[typeHash % NUM_MONOMORPHIZED_HASH_BUCKETS];
|
|
|
|
MonomorphizedGenericStructHashEntry *hashEntry = NULL;
|
|
|
|
for (j = 0; j < hashArray->count; j += 1)
|
|
{
|
|
match = 1;
|
|
|
|
for (k = 0; k < hashArray->elements[j].typeCount; k += 1)
|
|
{
|
|
if (hashArray->elements[j].types[k] != genericTypeTags[k])
|
|
{
|
|
match = 0;
|
|
break;
|
|
}
|
|
}
|
|
|
|
if (match)
|
|
{
|
|
hashEntry = &hashArray->elements[i];
|
|
break;
|
|
}
|
|
}
|
|
|
|
if (hashEntry == NULL)
|
|
{
|
|
StructTypeDeclaration *structTypeDeclaration =
|
|
CompileMonomorphizedGenericStruct(
|
|
&genericStructTypeDeclarations[i],
|
|
genericTypeTags,
|
|
typeTag->genericArgumentCount);
|
|
|
|
hashArray->elements = realloc(
|
|
hashArray->elements,
|
|
sizeof(MonomorphizedGenericStructHashEntry) *
|
|
(hashArray->count + 1));
|
|
hashArray->elements[hashArray->count].key = typeHash;
|
|
hashArray->elements[hashArray->count].types =
|
|
malloc(sizeof(TypeTag *) * typeTag->genericArgumentCount);
|
|
hashArray->elements[hashArray->count].typeCount =
|
|
typeTag->genericArgumentCount;
|
|
hashArray->elements[hashArray->count].structDeclaration =
|
|
structTypeDeclaration;
|
|
for (j = 0; j < typeTag->genericArgumentCount; j += 1)
|
|
{
|
|
hashArray->elements[hashArray->count].types[j] =
|
|
genericTypeTags[j];
|
|
}
|
|
hashArray->count += 1;
|
|
|
|
hashEntry = &hashArray->elements[hashArray->count - 1];
|
|
}
|
|
|
|
return hashEntry->structDeclaration;
|
|
}
|
|
}
|
|
|
|
fprintf(stderr, "Could not find generic struct declaration!");
|
|
return NULL;
|
|
}
|
|
|
|
static LLVMTypeRef ResolveType(TypeTag *typeTag)
|
|
{
|
|
if (typeTag->type == Primitive)
|
|
{
|
|
return WraithTypeToLLVMType(typeTag->value.primitiveType);
|
|
}
|
|
else if (typeTag->type == Custom)
|
|
{
|
|
return LookupCustomType(typeTag->value.customType);
|
|
}
|
|
else if (typeTag->type == Reference)
|
|
{
|
|
return LLVMPointerType(ResolveType(typeTag->value.referenceType), 0);
|
|
}
|
|
else if (typeTag->type == Generic)
|
|
{
|
|
return LookupGenericType(typeTag->value.genericType)->type;
|
|
}
|
|
else if (typeTag->type == ConcreteGeneric)
|
|
{
|
|
return LookupGenericStructType(&typeTag->value.concreteGenericType)
|
|
->structType;
|
|
}
|
|
else
|
|
{
|
|
fprintf(stderr, "Unknown type node!\n");
|
|
return NULL;
|
|
}
|
|
}
|
|
|
|
static void AddSystemFunction(
|
|
char *name,
|
|
LLVMTypeRef functionType,
|
|
LLVMValueRef function)
|
|
{
|
|
systemFunctions = realloc(
|
|
systemFunctions,
|
|
sizeof(SystemFunction) * (systemFunctionCount + 1));
|
|
systemFunctions[systemFunctionCount].name = strdup(name);
|
|
systemFunctions[systemFunctionCount].functionType = functionType;
|
|
systemFunctions[systemFunctionCount].function = function;
|
|
systemFunctionCount += 1;
|
|
}
|
|
|
|
static SystemFunction *LookupSystemFunction(Node *systemCallExpression)
|
|
{
|
|
uint32_t i;
|
|
char *name = systemCallExpression->systemCall.identifier->identifier.name;
|
|
|
|
for (i = 0; i < systemFunctionCount; i += 1)
|
|
{
|
|
if (strcmp(name, systemFunctions[i].name) == 0)
|
|
{
|
|
return &systemFunctions[i];
|
|
}
|
|
}
|
|
|
|
fprintf(stderr, "%s %s %s", "System function", name, "not found!");
|
|
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 DeclareStructFunction(
|
|
StructTypeDeclaration *structTypeDeclaration,
|
|
LLVMValueRef function,
|
|
LLVMTypeRef returnType,
|
|
uint8_t isStatic,
|
|
char *name)
|
|
{
|
|
uint32_t index = structTypeDeclaration->functionCount;
|
|
|
|
structTypeDeclaration->functions = realloc(
|
|
structTypeDeclaration->functions,
|
|
sizeof(StructTypeFunction) *
|
|
(structTypeDeclaration->functionCount + 1));
|
|
structTypeDeclaration->functions[index].name = strdup(name);
|
|
structTypeDeclaration->functions[index].function = function;
|
|
structTypeDeclaration->functions[index].returnType = returnType;
|
|
structTypeDeclaration->functions[index].isStatic = isStatic;
|
|
structTypeDeclaration->functionCount += 1;
|
|
}
|
|
|
|
static void DeclareGenericStructFunction(
|
|
StructTypeDeclaration *structTypeDeclaration,
|
|
Node *functionDeclarationNode,
|
|
uint8_t isStatic,
|
|
char *name)
|
|
{
|
|
uint32_t i, index;
|
|
|
|
index = structTypeDeclaration->genericFunctionCount;
|
|
structTypeDeclaration->genericFunctions = realloc(
|
|
structTypeDeclaration->genericFunctions,
|
|
sizeof(StructTypeGenericFunction) *
|
|
(structTypeDeclaration->genericFunctionCount + 1));
|
|
structTypeDeclaration->genericFunctions[index].name = strdup(name);
|
|
structTypeDeclaration->genericFunctions[index].parentStruct =
|
|
structTypeDeclaration;
|
|
structTypeDeclaration->genericFunctions[index].functionDeclarationNode =
|
|
functionDeclarationNode;
|
|
structTypeDeclaration->genericFunctions[index].isStatic = isStatic;
|
|
|
|
for (i = 0; i < NUM_MONOMORPHIZED_HASH_BUCKETS; i += 1)
|
|
{
|
|
structTypeDeclaration->genericFunctions[index]
|
|
.monomorphizedFunctions[i]
|
|
.elements = NULL;
|
|
structTypeDeclaration->genericFunctions[index]
|
|
.monomorphizedFunctions[i]
|
|
.count = 0;
|
|
}
|
|
|
|
structTypeDeclaration->genericFunctionCount += 1;
|
|
}
|
|
|
|
/* FIXME: lots of duplication with non-generic function compile */
|
|
static StructTypeFunction CompileGenericFunction(
|
|
StructTypeDeclaration *structTypeDeclaration,
|
|
TypeTag **resolvedGenericArgumentTypes,
|
|
uint32_t genericArgumentTypeCount,
|
|
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;
|
|
LLVMTypeRef returnType;
|
|
|
|
PushScopeFrame(scope);
|
|
|
|
for (i = 0; i < genericArgumentTypeCount; i += 1)
|
|
{
|
|
AddGenericVariable(
|
|
scope,
|
|
resolvedGenericArgumentTypes[i],
|
|
functionDeclaration->functionDeclaration.functionSignature
|
|
->functionSignature.genericDeclarations->genericDeclarations
|
|
.declarations[i]
|
|
->genericDeclaration.identifier->identifier.name);
|
|
}
|
|
|
|
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;
|
|
}
|
|
}
|
|
}
|
|
|
|
/* FIXME: these cats need to be realloc'd */
|
|
char *functionName = strdup(structTypeDeclaration->name);
|
|
strcat(functionName, "_");
|
|
strcat(
|
|
functionName,
|
|
functionSignature->functionSignature.identifier->identifier.name);
|
|
|
|
for (i = 0; i < genericArgumentTypeCount; i += 1)
|
|
{
|
|
strcat(functionName, TypeTagToString(resolvedGenericArgumentTypes[i]));
|
|
}
|
|
|
|
if (!isStatic)
|
|
{
|
|
paramTypes[paramIndex] = structTypeDeclaration->structPointerType;
|
|
paramIndex += 1;
|
|
}
|
|
|
|
for (i = 0; i < functionSignature->functionSignature.arguments
|
|
->functionSignatureArguments.count;
|
|
i += 1)
|
|
{
|
|
paramTypes[paramIndex] =
|
|
ResolveType(functionSignature->functionSignature.arguments
|
|
->functionSignatureArguments.sequence[i]
|
|
->declaration.identifier->typeTag);
|
|
|
|
paramIndex += 1;
|
|
}
|
|
|
|
returnType =
|
|
ResolveType(functionSignature->functionSignature.identifier->typeTag);
|
|
|
|
LLVMTypeRef functionType =
|
|
LLVMFunctionType(returnType, paramTypes, paramIndex, 0);
|
|
|
|
LLVMValueRef function = LLVMAddFunction(
|
|
structTypeDeclaration->module,
|
|
functionName,
|
|
functionType);
|
|
|
|
LLVMBasicBlockRef entry = LLVMAppendBasicBlock(function, "entry");
|
|
LLVMBuilderRef builder = LLVMCreateBuilder();
|
|
LLVMPositionBuilderAtEnd(builder, entry);
|
|
|
|
if (!isStatic)
|
|
{
|
|
LLVMValueRef wStructPointer = LLVMGetParam(function, 0);
|
|
AddStructVariablesToScope(
|
|
structTypeDeclaration,
|
|
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(
|
|
structTypeDeclaration,
|
|
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!");
|
|
}
|
|
|
|
LLVMDisposeBuilder(builder);
|
|
PopScopeFrame(scope);
|
|
free(functionName);
|
|
|
|
StructTypeFunction structTypeFunction;
|
|
structTypeFunction.name = strdup(
|
|
functionSignature->functionSignature.identifier->identifier.name);
|
|
structTypeFunction.function = function;
|
|
structTypeFunction.returnType = returnType;
|
|
structTypeFunction.isStatic = isStatic;
|
|
|
|
return structTypeFunction;
|
|
}
|
|
|
|
static LLVMValueRef LookupGenericFunction(
|
|
StructTypeGenericFunction *genericFunction,
|
|
Node *functionCallExpression,
|
|
LLVMTypeRef *pReturnType,
|
|
uint8_t *pStatic)
|
|
{
|
|
uint32_t i, j;
|
|
uint64_t typeHash;
|
|
uint8_t match = 0;
|
|
uint32_t genericArgumentTypeCount =
|
|
genericFunction->functionDeclarationNode->functionDeclaration
|
|
.functionSignature->functionSignature.genericDeclarations
|
|
->genericDeclarations.count;
|
|
TypeTag *resolvedGenericArgumentTypes[genericArgumentTypeCount];
|
|
uint32_t argumentCount = 0;
|
|
TypeTag
|
|
*argumentTypes[functionCallExpression->functionCallExpression
|
|
.argumentSequence->functionArgumentSequence.count];
|
|
|
|
for (i = 0; i < functionCallExpression->functionCallExpression
|
|
.argumentSequence->functionArgumentSequence.count;
|
|
i += 1)
|
|
{
|
|
argumentTypes[i] =
|
|
functionCallExpression->functionCallExpression.argumentSequence
|
|
->functionArgumentSequence.sequence[i]
|
|
->typeTag;
|
|
|
|
argumentCount += 1;
|
|
}
|
|
|
|
if (functionCallExpression->functionCallExpression.genericArguments
|
|
->genericArguments.count > 0)
|
|
{
|
|
for (i = 0; i < functionCallExpression->functionCallExpression
|
|
.genericArguments->genericArguments.count;
|
|
i += 1)
|
|
{
|
|
resolvedGenericArgumentTypes[i] =
|
|
functionCallExpression->functionCallExpression.genericArguments
|
|
->genericArguments.arguments[i]
|
|
->genericArgument.type->typeTag;
|
|
}
|
|
}
|
|
else /* we have to infer the generics */
|
|
{
|
|
for (i = 0; i < genericArgumentTypeCount; i += 1)
|
|
{
|
|
for (j = 0;
|
|
j <
|
|
genericFunction->functionDeclarationNode->functionDeclaration
|
|
.functionSignature->functionSignature.arguments
|
|
->functionSignatureArguments.count;
|
|
j += 1)
|
|
{
|
|
if (genericFunction->functionDeclarationNode
|
|
->functionDeclaration.functionSignature
|
|
->functionSignature.arguments
|
|
->functionSignatureArguments.sequence[j]
|
|
->declaration.identifier->typeTag->type ==
|
|
Generic &&
|
|
strcmp(
|
|
genericFunction->functionDeclarationNode
|
|
->functionDeclaration.functionSignature
|
|
->functionSignature.arguments
|
|
->functionSignatureArguments.sequence[j]
|
|
->declaration.identifier->typeTag->value
|
|
.genericType,
|
|
genericFunction->functionDeclarationNode
|
|
->functionDeclaration.functionSignature
|
|
->functionSignature.genericDeclarations
|
|
->genericDeclarations.declarations[i]
|
|
->genericDeclaration.identifier->identifier.name) ==
|
|
0)
|
|
{
|
|
resolvedGenericArgumentTypes[i] = argumentTypes[j];
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
/* Concretize generics if we are compiling nested generic functions */
|
|
for (i = 0; i < genericArgumentTypeCount; i += 1)
|
|
{
|
|
resolvedGenericArgumentTypes[i] =
|
|
ConcretizeType(resolvedGenericArgumentTypes[i]);
|
|
}
|
|
|
|
typeHash =
|
|
HashTypeTags(resolvedGenericArgumentTypes, genericArgumentTypeCount);
|
|
|
|
MonomorphizedGenericFunctionHashArray *hashArray =
|
|
&genericFunction->monomorphizedFunctions
|
|
[typeHash % NUM_MONOMORPHIZED_HASH_BUCKETS];
|
|
|
|
MonomorphizedGenericFunctionHashEntry *hashEntry = NULL;
|
|
for (i = 0; i < hashArray->count; i += 1)
|
|
{
|
|
match = 1;
|
|
|
|
for (j = 0; j < hashArray->elements[i].typeCount; j += 1)
|
|
{
|
|
if (hashArray->elements[i].types[j] !=
|
|
resolvedGenericArgumentTypes[j])
|
|
{
|
|
match = 0;
|
|
break;
|
|
}
|
|
}
|
|
|
|
if (match)
|
|
{
|
|
hashEntry = &hashArray->elements[i];
|
|
break;
|
|
}
|
|
}
|
|
|
|
if (hashEntry == NULL)
|
|
{
|
|
StructTypeFunction function = CompileGenericFunction(
|
|
genericFunction->parentStruct,
|
|
resolvedGenericArgumentTypes,
|
|
genericArgumentTypeCount,
|
|
genericFunction->functionDeclarationNode);
|
|
|
|
hashArray->elements = realloc(
|
|
hashArray->elements,
|
|
sizeof(MonomorphizedGenericFunctionHashEntry) *
|
|
(hashArray->count + 1));
|
|
hashArray->elements[hashArray->count].key = typeHash;
|
|
hashArray->elements[hashArray->count].types =
|
|
malloc(sizeof(TypeTag *) * genericArgumentTypeCount);
|
|
hashArray->elements[hashArray->count].typeCount =
|
|
genericArgumentTypeCount;
|
|
hashArray->elements[hashArray->count].function = function;
|
|
for (i = 0; i < genericArgumentTypeCount; i += 1)
|
|
{
|
|
hashArray->elements[hashArray->count].types[i] =
|
|
resolvedGenericArgumentTypes[i];
|
|
}
|
|
hashArray->count += 1;
|
|
|
|
hashEntry = &hashArray->elements[hashArray->count - 1];
|
|
}
|
|
|
|
*pReturnType = hashEntry->function.returnType;
|
|
*pStatic = genericFunction->isStatic;
|
|
|
|
return hashEntry->function.function;
|
|
}
|
|
|
|
static LLVMValueRef LookupFunctionByType(
|
|
LLVMTypeRef structType,
|
|
Node *functionCallExpression,
|
|
LLVMTypeRef *pReturnType,
|
|
uint8_t *pStatic)
|
|
{
|
|
uint32_t i, j;
|
|
/* FIXME: hot garbage */
|
|
char *name = functionCallExpression->functionCallExpression.identifier
|
|
->accessExpression.accessor->identifier.name;
|
|
|
|
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;
|
|
}
|
|
}
|
|
|
|
for (j = 0; j < structTypeDeclarations[i].genericFunctionCount;
|
|
j += 1)
|
|
{
|
|
if (strcmp(
|
|
structTypeDeclarations[i].genericFunctions[j].name,
|
|
name) == 0)
|
|
{
|
|
return LookupGenericFunction(
|
|
&structTypeDeclarations[i].genericFunctions[j],
|
|
functionCallExpression,
|
|
pReturnType,
|
|
pStatic);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
fprintf(stderr, "Could not find struct function!\n");
|
|
return NULL;
|
|
}
|
|
|
|
static LLVMValueRef LookupFunctionByPointerType(
|
|
LLVMTypeRef structPointerType,
|
|
Node *functionCallExpression,
|
|
LLVMTypeRef *pReturnType,
|
|
uint8_t *pStatic)
|
|
{
|
|
uint32_t i, j;
|
|
/* FIXME: hot garbage */
|
|
char *name = functionCallExpression->functionCallExpression.identifier
|
|
->accessExpression.accessor->identifier.name;
|
|
|
|
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;
|
|
}
|
|
}
|
|
|
|
for (j = 0; j < structTypeDeclarations[i].genericFunctionCount;
|
|
j += 1)
|
|
{
|
|
if (strcmp(
|
|
structTypeDeclarations[i].genericFunctions[j].name,
|
|
name) == 0)
|
|
{
|
|
return LookupGenericFunction(
|
|
&structTypeDeclarations[i].genericFunctions[j],
|
|
functionCallExpression,
|
|
pReturnType,
|
|
pStatic);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
fprintf(stderr, "Could not find struct function!\n");
|
|
return NULL;
|
|
}
|
|
|
|
static LLVMValueRef LookupFunctionByInstance(
|
|
LLVMValueRef structPointer,
|
|
Node *functionCallExpression,
|
|
LLVMTypeRef *pReturnType,
|
|
uint8_t *pStatic)
|
|
{
|
|
return LookupFunctionByPointerType(
|
|
LLVMTypeOf(structPointer),
|
|
functionCallExpression,
|
|
pReturnType,
|
|
pStatic);
|
|
}
|
|
|
|
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(
|
|
StructTypeDeclaration *structTypeDeclaration,
|
|
LLVMBuilderRef builder,
|
|
Node *binaryExpression)
|
|
{
|
|
LLVMValueRef left = CompileExpression(
|
|
structTypeDeclaration,
|
|
builder,
|
|
binaryExpression->binaryExpression.left);
|
|
|
|
LLVMValueRef right = CompileExpression(
|
|
structTypeDeclaration,
|
|
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(
|
|
StructTypeDeclaration *structTypeDeclaration,
|
|
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,
|
|
&functionReturnType,
|
|
&isStatic);
|
|
}
|
|
else
|
|
{
|
|
structInstance = FindVariablePointer(
|
|
functionCallExpression->functionCallExpression.identifier
|
|
->accessExpression.accessee->identifier.name);
|
|
function = LookupFunctionByInstance(
|
|
structInstance,
|
|
functionCallExpression,
|
|
&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(
|
|
structTypeDeclaration,
|
|
builder,
|
|
functionCallExpression->functionCallExpression.argumentSequence
|
|
->functionArgumentSequence.sequence[i]);
|
|
argumentCount += 1;
|
|
}
|
|
|
|
if (LLVMGetTypeKind(functionReturnType) != LLVMVoidTypeKind)
|
|
{
|
|
returnName = "callReturn";
|
|
}
|
|
|
|
return LLVMBuildCall(builder, function, args, argumentCount, returnName);
|
|
}
|
|
|
|
static LLVMValueRef CompileSystemCallExpression(
|
|
StructTypeDeclaration *structTypeDeclaration,
|
|
LLVMBuilderRef builder,
|
|
Node *systemCallExpression)
|
|
{
|
|
uint32_t i;
|
|
uint32_t argumentCount = systemCallExpression->systemCall.argumentSequence
|
|
->functionArgumentSequence.count;
|
|
LLVMValueRef args[argumentCount];
|
|
char *returnName = "";
|
|
|
|
for (i = 0; i < systemCallExpression->systemCall.argumentSequence
|
|
->functionArgumentSequence.count;
|
|
i += 1)
|
|
{
|
|
args[i] = CompileExpression(
|
|
structTypeDeclaration,
|
|
builder,
|
|
systemCallExpression->systemCall.argumentSequence
|
|
->functionArgumentSequence.sequence[i]);
|
|
}
|
|
|
|
SystemFunction *systemFunction = LookupSystemFunction(systemCallExpression);
|
|
|
|
if (systemFunction == NULL)
|
|
{
|
|
/* special case for sizeof */
|
|
if (strcmp(
|
|
systemCallExpression->systemCall.identifier->identifier.name,
|
|
"sizeof") == 0)
|
|
{
|
|
TypeTag *typeTag =
|
|
systemCallExpression->systemCall.genericArguments
|
|
->genericArguments.arguments[0]
|
|
->type.typeNode->typeTag;
|
|
|
|
return LLVMSizeOf(ResolveType(ConcretizeType(typeTag)));
|
|
}
|
|
else
|
|
{
|
|
fprintf(stderr, "System function not found!");
|
|
return NULL;
|
|
}
|
|
}
|
|
|
|
if (LLVMGetTypeKind(LLVMGetReturnType(systemFunction->functionType)) !=
|
|
LLVMVoidTypeKind)
|
|
{
|
|
returnName = "callReturn";
|
|
}
|
|
|
|
return LLVMBuildCall(
|
|
builder,
|
|
systemFunction->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->typeTag);
|
|
return LLVMBuildMalloc(builder, type, "allocation");
|
|
}
|
|
|
|
static LLVMValueRef CompileExpression(
|
|
StructTypeDeclaration *structTypeDeclaration,
|
|
LLVMBuilderRef builder,
|
|
Node *expression)
|
|
{
|
|
switch (expression->syntaxKind)
|
|
{
|
|
case AccessExpression:
|
|
return CompileAccessExpression(builder, expression);
|
|
|
|
case AllocExpression:
|
|
return CompileAllocExpression(builder, expression);
|
|
|
|
case BinaryExpression:
|
|
return CompileBinaryExpression(
|
|
structTypeDeclaration,
|
|
builder,
|
|
expression);
|
|
|
|
case FunctionCallExpression:
|
|
return CompileFunctionCallExpression(
|
|
structTypeDeclaration,
|
|
builder,
|
|
expression);
|
|
|
|
case Identifier:
|
|
return FindVariableValue(builder, expression->identifier.name);
|
|
|
|
case Number:
|
|
return CompileNumber(expression);
|
|
|
|
case StringLiteral:
|
|
return CompileString(builder, expression);
|
|
|
|
case SystemCall:
|
|
return CompileSystemCallExpression(
|
|
structTypeDeclaration,
|
|
builder,
|
|
expression);
|
|
}
|
|
|
|
fprintf(stderr, "Unknown expression kind!\n");
|
|
return NULL;
|
|
}
|
|
|
|
static LLVMBasicBlockRef CompileReturn(
|
|
StructTypeDeclaration *structTypeDeclaration,
|
|
LLVMBuilderRef builder,
|
|
LLVMValueRef function,
|
|
Node *returnStatemement)
|
|
{
|
|
LLVMValueRef expression = CompileExpression(
|
|
structTypeDeclaration,
|
|
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.identifier->typeTag),
|
|
ptrName);
|
|
|
|
free(ptrName);
|
|
|
|
AddLocalVariable(scope, variable, NULL, variableName);
|
|
|
|
return variable;
|
|
}
|
|
|
|
static LLVMBasicBlockRef CompileAssignment(
|
|
StructTypeDeclaration *structTypeDeclaration,
|
|
LLVMBuilderRef builder,
|
|
LLVMValueRef function,
|
|
Node *assignmentStatement)
|
|
{
|
|
LLVMValueRef result = CompileExpression(
|
|
structTypeDeclaration,
|
|
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(
|
|
StructTypeDeclaration *structTypeDeclaration,
|
|
LLVMBuilderRef builder,
|
|
LLVMValueRef function,
|
|
Node *ifStatement)
|
|
{
|
|
uint32_t i;
|
|
LLVMValueRef conditional = CompileExpression(
|
|
structTypeDeclaration,
|
|
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(
|
|
structTypeDeclaration,
|
|
builder,
|
|
function,
|
|
ifStatement->ifStatement.statementSequence->statementSequence
|
|
.sequence[i]);
|
|
}
|
|
|
|
LLVMBuildBr(builder, afterCond);
|
|
LLVMPositionBuilderAtEnd(builder, afterCond);
|
|
|
|
return afterCond;
|
|
}
|
|
|
|
static LLVMBasicBlockRef CompileIfElseStatement(
|
|
StructTypeDeclaration *structTypeDeclaration,
|
|
LLVMBuilderRef builder,
|
|
LLVMValueRef function,
|
|
Node *ifElseStatement)
|
|
{
|
|
uint32_t i;
|
|
LLVMValueRef conditional = CompileExpression(
|
|
structTypeDeclaration,
|
|
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(
|
|
structTypeDeclaration,
|
|
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(
|
|
structTypeDeclaration,
|
|
builder,
|
|
function,
|
|
ifElseStatement->ifElseStatement.elseStatement
|
|
->statementSequence.sequence[i]);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
CompileStatement(
|
|
structTypeDeclaration,
|
|
builder,
|
|
function,
|
|
ifElseStatement->ifElseStatement.elseStatement);
|
|
}
|
|
|
|
LLVMBuildBr(builder, afterCond);
|
|
LLVMPositionBuilderAtEnd(builder, afterCond);
|
|
|
|
return afterCond;
|
|
}
|
|
|
|
static LLVMBasicBlockRef CompileForLoopStatement(
|
|
StructTypeDeclaration *structTypeDeclaration,
|
|
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.identifier->typeTag);
|
|
|
|
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(
|
|
structTypeDeclaration,
|
|
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(
|
|
StructTypeDeclaration *structTypeDeclaration,
|
|
LLVMBuilderRef builder,
|
|
LLVMValueRef function,
|
|
Node *statement)
|
|
{
|
|
switch (statement->syntaxKind)
|
|
{
|
|
case Assignment:
|
|
return CompileAssignment(
|
|
structTypeDeclaration,
|
|
builder,
|
|
function,
|
|
statement);
|
|
|
|
case Declaration:
|
|
CompileFunctionVariableDeclaration(builder, function, statement);
|
|
return LLVMGetLastBasicBlock(function);
|
|
|
|
case ForLoop:
|
|
return CompileForLoopStatement(
|
|
structTypeDeclaration,
|
|
builder,
|
|
function,
|
|
statement);
|
|
|
|
case FunctionCallExpression:
|
|
CompileFunctionCallExpression(
|
|
structTypeDeclaration,
|
|
builder,
|
|
statement);
|
|
return LLVMGetLastBasicBlock(function);
|
|
|
|
case IfStatement:
|
|
return CompileIfStatement(
|
|
structTypeDeclaration,
|
|
builder,
|
|
function,
|
|
statement);
|
|
|
|
case IfElseStatement:
|
|
return CompileIfElseStatement(
|
|
structTypeDeclaration,
|
|
builder,
|
|
function,
|
|
statement);
|
|
|
|
case Return:
|
|
return CompileReturn(
|
|
structTypeDeclaration,
|
|
builder,
|
|
function,
|
|
statement);
|
|
|
|
case ReturnVoid:
|
|
return CompileReturnVoid(builder, function);
|
|
|
|
case SystemCall:
|
|
CompileSystemCallExpression(structTypeDeclaration, builder, statement);
|
|
return LLVMGetLastBasicBlock(function);
|
|
}
|
|
|
|
fprintf(stderr, "Unknown statement kind!\n");
|
|
return NULL;
|
|
}
|
|
|
|
static void CompileFunction(
|
|
StructTypeDeclaration *structTypeDeclaration,
|
|
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;
|
|
}
|
|
}
|
|
}
|
|
|
|
char *functionName = strdup(structTypeDeclaration->name);
|
|
uint32_t nameLen = strlen(functionName);
|
|
nameLen +=
|
|
2 +
|
|
strlen(
|
|
functionSignature->functionSignature.identifier->identifier.name);
|
|
functionName = realloc(functionName, sizeof(char) * nameLen);
|
|
strcat(functionName, "_");
|
|
strcat(
|
|
functionName,
|
|
functionSignature->functionSignature.identifier->identifier.name);
|
|
|
|
if (functionSignature->functionSignature.genericDeclarations
|
|
->genericDeclarations.count == 0)
|
|
{
|
|
PushScopeFrame(scope);
|
|
|
|
if (!isStatic)
|
|
{
|
|
paramTypes[paramIndex] = structTypeDeclaration->structPointerType;
|
|
paramIndex += 1;
|
|
}
|
|
|
|
for (i = 0; i < functionSignature->functionSignature.arguments
|
|
->functionSignatureArguments.count;
|
|
i += 1)
|
|
{
|
|
paramTypes[paramIndex] =
|
|
ResolveType(functionSignature->functionSignature.arguments
|
|
->functionSignatureArguments.sequence[i]
|
|
->declaration.identifier->typeTag);
|
|
paramIndex += 1;
|
|
}
|
|
|
|
LLVMTypeRef returnType = ResolveType(
|
|
functionSignature->functionSignature.identifier->typeTag);
|
|
LLVMTypeRef functionType =
|
|
LLVMFunctionType(returnType, paramTypes, paramIndex, 0);
|
|
|
|
LLVMValueRef function = LLVMAddFunction(
|
|
structTypeDeclaration->module,
|
|
functionName,
|
|
functionType);
|
|
|
|
DeclareStructFunction(
|
|
structTypeDeclaration,
|
|
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(
|
|
structTypeDeclaration,
|
|
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(
|
|
structTypeDeclaration,
|
|
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!");
|
|
}
|
|
|
|
LLVMDisposeBuilder(builder);
|
|
|
|
PopScopeFrame(scope);
|
|
}
|
|
else
|
|
{
|
|
DeclareGenericStructFunction(
|
|
structTypeDeclaration,
|
|
functionDeclaration,
|
|
isStatic,
|
|
functionSignature->functionSignature.identifier->identifier.name);
|
|
}
|
|
|
|
free(functionName);
|
|
}
|
|
|
|
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;
|
|
char *structName = node->structDeclaration.identifier->identifier.name;
|
|
|
|
PushScopeFrame(scope);
|
|
|
|
if (node->structDeclaration.genericDeclarations->genericDeclarations
|
|
.count == 0)
|
|
{
|
|
LLVMTypeRef wStructType = LLVMStructCreateNamed(context, structName);
|
|
LLVMTypeRef wStructPointerType = LLVMPointerType(
|
|
wStructType,
|
|
0); /* FIXME: is this address space correct? */
|
|
|
|
StructTypeDeclaration *structTypeDeclaration = AddStructDeclaration(
|
|
module,
|
|
wStructType,
|
|
wStructPointerType,
|
|
structName);
|
|
|
|
/* first, build the structure definition */
|
|
for (i = 0; i < declarationCount; i += 1)
|
|
{
|
|
currentDeclarationNode =
|
|
node->structDeclaration.declarationSequence->declarationSequence
|
|
.sequence[i];
|
|
|
|
switch (currentDeclarationNode->syntaxKind)
|
|
{
|
|
case Declaration: /* FIXME: this is badly named */
|
|
types[fieldCount] = ResolveType(
|
|
currentDeclarationNode->declaration.identifier->typeTag);
|
|
AddFieldToStructDeclaration(
|
|
structTypeDeclaration,
|
|
currentDeclarationNode->declaration.identifier->identifier
|
|
.name);
|
|
fieldCount += 1;
|
|
break;
|
|
}
|
|
}
|
|
|
|
LLVMStructSetBody(wStructType, types, fieldCount, packed);
|
|
|
|
/* 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(structTypeDeclaration, currentDeclarationNode);
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
AddGenericStructDeclaration(module, node);
|
|
}
|
|
|
|
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);
|
|
StructTypeDeclaration *structTypeDeclaration =
|
|
AddStructDeclaration(module, structType, structPointerType, "Console");
|
|
|
|
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(
|
|
structTypeDeclaration,
|
|
printLineFunction,
|
|
LLVMInt8Type(),
|
|
1,
|
|
"PrintLine");
|
|
|
|
LLVMTypeRef mallocArg = LLVMInt64Type();
|
|
LLVMTypeRef mallocFunctionType =
|
|
LLVMFunctionType(LLVMInt64Type(), &mallocArg, 1, 0);
|
|
LLVMValueRef mallocFunction =
|
|
LLVMAddFunction(module, "malloc", mallocFunctionType);
|
|
LLVMSetLinkage(mallocFunction, LLVMExternalLinkage);
|
|
|
|
AddSystemFunction("malloc", mallocFunctionType, mallocFunction);
|
|
|
|
LLVMTypeRef freeArg = LLVMInt64Type();
|
|
LLVMTypeRef freeFunctionType =
|
|
LLVMFunctionType(LLVMVoidType(), &freeArg, 1, 0);
|
|
LLVMValueRef freeFunction =
|
|
LLVMAddFunction(module, "free", freeFunctionType);
|
|
LLVMSetLinkage(freeFunction, LLVMExternalLinkage);
|
|
|
|
AddSystemFunction("free", freeFunctionType, freeFunction);
|
|
|
|
LLVMDisposeBuilder(builder);
|
|
}
|
|
|
|
int Codegen(Node *node, uint32_t optimizationLevel)
|
|
{
|
|
scope = CreateScope();
|
|
|
|
structTypeDeclarations = NULL;
|
|
structTypeDeclarationCount = 0;
|
|
|
|
genericStructTypeDeclarations = NULL;
|
|
genericStructTypeDeclarationCount = 0;
|
|
|
|
systemFunctions = NULL;
|
|
systemFunctionCount = 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;
|
|
}
|