1327 lines
47 KiB
C#
1327 lines
47 KiB
C#
using System.Diagnostics;
|
|
using System.Diagnostics.CodeAnalysis;
|
|
using System.Globalization;
|
|
using System.Text;
|
|
using Syntax;
|
|
using Syntax.Node;
|
|
using Syntax.Tokenization;
|
|
|
|
namespace Generation.QBE;
|
|
|
|
public static class QBEGenerator
|
|
{
|
|
private static BoundSyntaxTree _syntaxTree = null!;
|
|
private static BoundDefinitionTable _definitionTable = null!;
|
|
|
|
private static QBEWriter _writer = null!;
|
|
private static List<CStringLiteral> _cStringLiterals = [];
|
|
private static List<StringLiteral> _stringLiterals = [];
|
|
private static Stack<string> _breakLabels = [];
|
|
private static Stack<string> _continueLabels = [];
|
|
private static Queue<(BoundAnonymousFuncNode Func, string Name)> _anonymousFunctions = [];
|
|
private static Dictionary<BoundImplementationFuncNode, string> _implFunctions = [];
|
|
private static Stack<Variable> _variables = [];
|
|
private static Stack<int> _variableScopes = [];
|
|
private static int _tmpIndex;
|
|
private static int _labelIndex;
|
|
private static int _anonymousFuncIndex;
|
|
private static int _cStringLiteralIndex;
|
|
private static int _stringLiteralIndex;
|
|
private static int _implFuncNameIndex;
|
|
private static bool _codeIsReachable = true;
|
|
|
|
public static string Emit(BoundSyntaxTree syntaxTree, BoundDefinitionTable definitionTable, string file)
|
|
{
|
|
_syntaxTree = syntaxTree;
|
|
_definitionTable = definitionTable;
|
|
|
|
_writer = new QBEWriter(file);
|
|
|
|
_cStringLiterals = [];
|
|
_stringLiterals = [];
|
|
_breakLabels = [];
|
|
_continueLabels = [];
|
|
_anonymousFunctions = [];
|
|
_implFunctions = [];
|
|
_variables = [];
|
|
_variableScopes = [];
|
|
_tmpIndex = 0;
|
|
_labelIndex = 0;
|
|
_anonymousFuncIndex = 0;
|
|
_cStringLiteralIndex = 0;
|
|
_stringLiteralIndex = 0;
|
|
_implFuncNameIndex = 0;
|
|
_codeIsReachable = true;
|
|
|
|
foreach (var structDef in _definitionTable.GetStructs())
|
|
{
|
|
EmitStructDefinition(structDef);
|
|
_writer.NewLine();
|
|
}
|
|
|
|
foreach (var trait in _definitionTable.GetTraits())
|
|
{
|
|
EmitTraitVTable(trait);
|
|
_writer.NewLine();
|
|
}
|
|
|
|
foreach (var funcDef in _syntaxTree.Definitions.OfType<BoundLocalFuncDefinitionNode>())
|
|
{
|
|
EmitFuncDefinition(funcDef, FuncName(funcDef), funcDef.Parameters, funcDef.ReturnType, funcDef.Body, funcDef.Exported);
|
|
_writer.NewLine();
|
|
}
|
|
|
|
while (_anonymousFunctions.TryDequeue(out var anon))
|
|
{
|
|
EmitFuncDefinition(anon.Func, anon.Name, anon.Func.Parameters, anon.Func.ReturnType, anon.Func.Body, false);
|
|
_writer.NewLine();
|
|
}
|
|
|
|
foreach (var (impl, name) in _implFunctions)
|
|
{
|
|
EmitFuncDefinition(impl, name, impl.Parameters, impl.ReturnType, impl.Body, false);
|
|
_writer.NewLine();
|
|
}
|
|
|
|
foreach (var cStringLiteral in _cStringLiterals)
|
|
{
|
|
_writer.WriteLine($"data {cStringLiteral.Name} = {{ b \"{cStringLiteral.Value}\", b 0 }}");
|
|
}
|
|
|
|
foreach (var stringLiteral in _stringLiterals)
|
|
{
|
|
var bytes = Encoding.UTF8.GetBytes(stringLiteral.Value).Select(b => $"b {b}");
|
|
_writer.WriteLine($"data {stringLiteral.Name} = {{ l {stringLiteral.Value.Length}, {string.Join(", ", bytes)} }}");
|
|
}
|
|
|
|
return _writer.ToString();
|
|
}
|
|
|
|
private static string TmpName()
|
|
{
|
|
return $"%t{++_tmpIndex}";
|
|
}
|
|
|
|
private static string LabelName()
|
|
{
|
|
return $"@l{++_labelIndex}";
|
|
}
|
|
|
|
private static string CStringName()
|
|
{
|
|
return $"$cstring{++_cStringLiteralIndex}";
|
|
}
|
|
|
|
private static string StringName()
|
|
{
|
|
return $"$string{++_stringLiteralIndex}";
|
|
}
|
|
|
|
private static string FuncName(BoundFuncDefinition funcDef)
|
|
{
|
|
return funcDef switch
|
|
{
|
|
BoundExternFuncDefinitionNode externFuncDefinition => $"${externFuncDefinition.CallName}",
|
|
BoundLocalFuncDefinitionNode localFuncDefinition => localFuncDefinition.Exported
|
|
? $"${localFuncDefinition.Name}"
|
|
: $"${localFuncDefinition.Namespace}_{localFuncDefinition.Name}",
|
|
_ => throw new ArgumentOutOfRangeException(nameof(funcDef))
|
|
};
|
|
}
|
|
|
|
private static string ImplFuncName(BoundTraitImplementationDefinitionNode implDef, string funcName)
|
|
{
|
|
return $"$impl{++_implFuncNameIndex}";
|
|
}
|
|
|
|
private static string CustomTypeName(NubCustomType customType)
|
|
{
|
|
return $":{customType.Namespace}_{customType.Name}";
|
|
}
|
|
|
|
private static void EmitStore(NubType type, string value, string destination)
|
|
{
|
|
var store = type switch
|
|
{
|
|
NubComplexType => "storel",
|
|
NubSimpleType simpleType => simpleType switch
|
|
{
|
|
NubFuncType or NubPointerType => "loadl",
|
|
NubPrimitiveType primitiveType => primitiveType.Kind switch
|
|
{
|
|
PrimitiveTypeKind.I64 or PrimitiveTypeKind.U64 => "storel",
|
|
PrimitiveTypeKind.I32 or PrimitiveTypeKind.U32 => "storew",
|
|
PrimitiveTypeKind.I16 or PrimitiveTypeKind.U16 => "storeh",
|
|
PrimitiveTypeKind.I8 or PrimitiveTypeKind.U8 or PrimitiveTypeKind.Bool => "storeb",
|
|
PrimitiveTypeKind.F64 => "stored",
|
|
PrimitiveTypeKind.F32 => "stores",
|
|
_ => throw new ArgumentOutOfRangeException()
|
|
},
|
|
_ => throw new ArgumentOutOfRangeException($"'{type}' type cannot be used in store instructions")
|
|
},
|
|
_ => throw new UnreachableException()
|
|
};
|
|
|
|
_writer.Indented($"{store} {value}, {destination}");
|
|
}
|
|
|
|
private static Val EmitLoad(NubType type, string from)
|
|
{
|
|
var into = TmpName();
|
|
var load = type switch
|
|
{
|
|
NubComplexType => "loadl",
|
|
NubSimpleType simpleType => simpleType switch
|
|
{
|
|
NubFuncType or NubPointerType => "loadl",
|
|
NubPrimitiveType primitiveType => primitiveType.Kind switch
|
|
{
|
|
PrimitiveTypeKind.I64 or PrimitiveTypeKind.U64 => "loadl",
|
|
PrimitiveTypeKind.I32 or PrimitiveTypeKind.U32 => "loadw",
|
|
PrimitiveTypeKind.I16 => "loadsh",
|
|
PrimitiveTypeKind.I8 => "loadsb",
|
|
PrimitiveTypeKind.U16 => "loaduh",
|
|
PrimitiveTypeKind.U8 or PrimitiveTypeKind.Bool => "loadub",
|
|
PrimitiveTypeKind.F64 => "loadd",
|
|
PrimitiveTypeKind.F32 => "loads",
|
|
_ => throw new ArgumentOutOfRangeException()
|
|
},
|
|
_ => throw new ArgumentOutOfRangeException($"'{type}' type cannot be used in load instructions")
|
|
},
|
|
_ => throw new UnreachableException()
|
|
};
|
|
|
|
_writer.Indented($"{into} {QBEAssign(type)} {load} {from}");
|
|
|
|
return new Val(into, type, ValKind.Direct);
|
|
}
|
|
|
|
private static void EmitMemcpy(string source, string destination, string length)
|
|
{
|
|
_writer.Indented($"call $nub_memcpy(l {source}, l {destination}, l {length})");
|
|
}
|
|
|
|
private static string EmitArraySizeInBytes(NubArrayType type, string array)
|
|
{
|
|
var size = TmpName();
|
|
_writer.Indented($"{size} =l loadl {array}");
|
|
_writer.Indented($"{size} =l mul {size}, {SizeOf(type.ElementType)}");
|
|
_writer.Indented($"{size} =l add {size}, 8");
|
|
return size;
|
|
}
|
|
|
|
private static string EmitCStringSizeInBytes(string cstring)
|
|
{
|
|
var size = TmpName();
|
|
_writer.Indented($"{size} =l call $nub_cstring_length(l {cstring})");
|
|
_writer.Indented($"{size} =l add {size}, 1");
|
|
return size;
|
|
}
|
|
|
|
private static string EmitStringSizeInBytes(string nubstring)
|
|
{
|
|
var size = TmpName();
|
|
_writer.Indented($"{size} =l loadl {nubstring}");
|
|
_writer.Indented($"{size} =l add {size}, 8");
|
|
return size;
|
|
}
|
|
|
|
private static bool EmitTryMoveInto(BoundExpressionNode source, string destinationPointer)
|
|
{
|
|
switch (source)
|
|
{
|
|
case BoundArrayInitializerNode arrayInitializer:
|
|
{
|
|
_writer.WriteDebugLocation(arrayInitializer);
|
|
EmitStore(source.Type, EmitUnwrap(EmitArrayInitializer(arrayInitializer)), destinationPointer);
|
|
return true;
|
|
}
|
|
case BoundStructInitializerNode structInitializer:
|
|
{
|
|
_writer.WriteDebugLocation(structInitializer);
|
|
EmitStructInitializer(structInitializer, destinationPointer);
|
|
return true;
|
|
}
|
|
case BoundLiteralNode { Kind: LiteralKind.String } literal:
|
|
{
|
|
_writer.WriteDebugLocation(literal);
|
|
EmitStore(source.Type, EmitUnwrap(EmitLiteral(literal)), destinationPointer);
|
|
return true;
|
|
}
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
private static void EmitCopyIntoOrInitialize(BoundExpressionNode source, string destinationPointer)
|
|
{
|
|
// If the source is a value which is not used yet such as an array/struct initializer or literal, we can skip copying
|
|
if (EmitTryMoveInto(source, destinationPointer))
|
|
{
|
|
return;
|
|
}
|
|
|
|
var value = EmitUnwrap(EmitExpression(source));
|
|
|
|
switch (source.Type)
|
|
{
|
|
case NubComplexType complexType:
|
|
{
|
|
var size = complexType switch
|
|
{
|
|
NubArrayType arrayType => EmitArraySizeInBytes(arrayType, value),
|
|
NubCStringType => EmitCStringSizeInBytes(value),
|
|
NubStringType => EmitStringSizeInBytes(value),
|
|
NubCustomType customType => SizeOf(customType).ToString(),
|
|
_ => throw new ArgumentOutOfRangeException(nameof(complexType))
|
|
};
|
|
|
|
switch (complexType)
|
|
{
|
|
case NubArrayType:
|
|
case NubCStringType:
|
|
case NubStringType:
|
|
{
|
|
var buffer = TmpName();
|
|
_writer.Indented($"{buffer} =l alloc8 {size}");
|
|
EmitMemcpy(value, buffer, size);
|
|
EmitStore(source.Type, buffer, destinationPointer);
|
|
return;
|
|
}
|
|
case NubCustomType:
|
|
{
|
|
EmitMemcpy(value, destinationPointer, size);
|
|
return;
|
|
}
|
|
default:
|
|
{
|
|
throw new ArgumentOutOfRangeException(nameof(complexType));
|
|
}
|
|
}
|
|
}
|
|
case NubSimpleType simpleType:
|
|
{
|
|
EmitStore(simpleType, value, destinationPointer);
|
|
return;
|
|
}
|
|
default:
|
|
{
|
|
throw new ArgumentOutOfRangeException(nameof(source.Type));
|
|
}
|
|
}
|
|
}
|
|
|
|
private static bool EmitTryCreateWithoutCopy(BoundExpressionNode source, [NotNullWhen(true)] out string? destination)
|
|
{
|
|
switch (source)
|
|
{
|
|
case BoundArrayInitializerNode:
|
|
case BoundStructInitializerNode:
|
|
case BoundLiteralNode { Kind: LiteralKind.String }:
|
|
{
|
|
destination = EmitUnwrap(EmitExpression(source));
|
|
return true;
|
|
}
|
|
}
|
|
|
|
destination = null;
|
|
return false;
|
|
}
|
|
|
|
private static string EmitCreateCopyOrInitialize(BoundExpressionNode source)
|
|
{
|
|
// If the source is a value which is not used yet such as an array/struct initializer or literal, we can skip copying
|
|
if (EmitTryCreateWithoutCopy(source, out var uncopiedValue))
|
|
{
|
|
return uncopiedValue;
|
|
}
|
|
|
|
var value = EmitUnwrap(EmitExpression(source));
|
|
|
|
switch (source.Type)
|
|
{
|
|
case NubComplexType complexType:
|
|
{
|
|
var destination = TmpName();
|
|
|
|
var size = complexType switch
|
|
{
|
|
NubArrayType arrayType => EmitArraySizeInBytes(arrayType, value),
|
|
NubCStringType => EmitCStringSizeInBytes(value),
|
|
NubStringType => EmitStringSizeInBytes(value),
|
|
NubCustomType customType => SizeOf(customType).ToString(),
|
|
_ => throw new ArgumentOutOfRangeException(nameof(complexType))
|
|
};
|
|
|
|
_writer.Indented($"{destination} =l alloc8 {size}");
|
|
EmitMemcpy(value, destination, size);
|
|
return destination;
|
|
}
|
|
case NubSimpleType:
|
|
{
|
|
return value;
|
|
}
|
|
default:
|
|
{
|
|
throw new ArgumentOutOfRangeException(nameof(source.Type));
|
|
}
|
|
}
|
|
}
|
|
|
|
private static string QBEAssign(NubType type)
|
|
{
|
|
return type switch
|
|
{
|
|
NubComplexType => "=l",
|
|
NubSimpleType simpleType => simpleType switch
|
|
{
|
|
NubFuncType or NubFuncType => "=l",
|
|
NubPrimitiveType primitiveType => primitiveType.Kind switch
|
|
{
|
|
PrimitiveTypeKind.I64 or PrimitiveTypeKind.U64 => "=l",
|
|
PrimitiveTypeKind.I32 or PrimitiveTypeKind.U32 => "=w",
|
|
PrimitiveTypeKind.I16 or PrimitiveTypeKind.U16 => "=w",
|
|
PrimitiveTypeKind.I8 or PrimitiveTypeKind.U8 or PrimitiveTypeKind.Bool => "=w",
|
|
PrimitiveTypeKind.F64 => "=d",
|
|
PrimitiveTypeKind.F32 => "=s",
|
|
_ => throw new ArgumentOutOfRangeException()
|
|
},
|
|
_ => throw new NotSupportedException($"'{type}' type cannot be used in variables")
|
|
},
|
|
_ => throw new UnreachableException()
|
|
};
|
|
}
|
|
|
|
private static int AlignmentOf(NubType type)
|
|
{
|
|
switch (type)
|
|
{
|
|
case NubPrimitiveType primitiveType:
|
|
{
|
|
return primitiveType.Kind switch
|
|
{
|
|
PrimitiveTypeKind.I64 or PrimitiveTypeKind.U64 or PrimitiveTypeKind.F64 => 8,
|
|
PrimitiveTypeKind.I32 or PrimitiveTypeKind.U32 or PrimitiveTypeKind.F32 => 4,
|
|
PrimitiveTypeKind.I16 or PrimitiveTypeKind.U16 => 2,
|
|
PrimitiveTypeKind.I8 or PrimitiveTypeKind.U8 or PrimitiveTypeKind.Bool => 1,
|
|
_ => throw new ArgumentOutOfRangeException()
|
|
};
|
|
}
|
|
case NubCustomType customType:
|
|
{
|
|
var structDef = _definitionTable.LookupStruct(customType.Namespace, customType.Name);
|
|
if (structDef.HasValue)
|
|
{
|
|
return structDef.Value.Fields.Max(f => AlignmentOf(f.Type));
|
|
}
|
|
|
|
var traitDef = _definitionTable.LookupTrait(customType.Namespace, customType.Name);
|
|
if (traitDef.HasValue)
|
|
{
|
|
return 8;
|
|
}
|
|
|
|
throw new UnreachableException();
|
|
}
|
|
case NubPointerType:
|
|
case NubArrayType:
|
|
case NubCStringType:
|
|
case NubStringType:
|
|
case NubFuncType:
|
|
return 8;
|
|
default:
|
|
throw new ArgumentOutOfRangeException();
|
|
}
|
|
}
|
|
|
|
private static int AlignTo(int offset, int alignment)
|
|
{
|
|
return (offset + alignment - 1) & ~(alignment - 1);
|
|
}
|
|
|
|
private static int SizeOf(NubType type)
|
|
{
|
|
switch (type)
|
|
{
|
|
case NubPrimitiveType primitiveType:
|
|
{
|
|
return primitiveType.Kind switch
|
|
{
|
|
PrimitiveTypeKind.I64 or PrimitiveTypeKind.U64 or PrimitiveTypeKind.F64 => 8,
|
|
PrimitiveTypeKind.I32 or PrimitiveTypeKind.U32 or PrimitiveTypeKind.F32 => 4,
|
|
PrimitiveTypeKind.I16 or PrimitiveTypeKind.U16 => 2,
|
|
PrimitiveTypeKind.I8 or PrimitiveTypeKind.U8 or PrimitiveTypeKind.Bool => 1,
|
|
_ => throw new ArgumentOutOfRangeException()
|
|
};
|
|
}
|
|
case NubCustomType customType:
|
|
{
|
|
var structDef = _definitionTable.LookupStruct(customType.Namespace, customType.Name);
|
|
if (structDef.HasValue)
|
|
{
|
|
var size = 0;
|
|
var maxAlignment = 1;
|
|
|
|
foreach (var field in structDef.Value.Fields)
|
|
{
|
|
var fieldAlignment = AlignmentOf(field.Type);
|
|
maxAlignment = Math.Max(maxAlignment, fieldAlignment);
|
|
|
|
size = AlignTo(size, fieldAlignment);
|
|
size += SizeOf(field.Type);
|
|
}
|
|
|
|
size = AlignTo(size, maxAlignment);
|
|
|
|
return size;
|
|
}
|
|
|
|
var traitDef = _definitionTable.LookupTrait(customType.Namespace, customType.Name);
|
|
if (traitDef.HasValue)
|
|
{
|
|
return 16;
|
|
}
|
|
|
|
throw new UnreachableException();
|
|
}
|
|
case NubPointerType:
|
|
case NubArrayType:
|
|
case NubCStringType:
|
|
case NubStringType:
|
|
case NubFuncType:
|
|
return 8;
|
|
default:
|
|
throw new ArgumentOutOfRangeException();
|
|
}
|
|
}
|
|
|
|
private static int OffsetOf(BoundStructDefinitionNode structDefinition, string member)
|
|
{
|
|
var offset = 0;
|
|
|
|
foreach (var field in structDefinition.Fields)
|
|
{
|
|
if (field.Name == member)
|
|
{
|
|
return offset;
|
|
}
|
|
|
|
var fieldAlignment = AlignmentOf(field.Type);
|
|
|
|
offset = AlignTo(offset, fieldAlignment);
|
|
offset += SizeOf(field.Type);
|
|
}
|
|
|
|
throw new UnreachableException($"Member '{member}' not found in struct");
|
|
}
|
|
|
|
private static string FuncQBETypeName(NubType type)
|
|
{
|
|
return type switch
|
|
{
|
|
NubCustomType customType => CustomTypeName(customType),
|
|
NubComplexType => "l",
|
|
NubSimpleType simpleType => simpleType switch
|
|
{
|
|
NubPointerType or NubFuncType => "l",
|
|
NubPrimitiveType primitiveType => primitiveType.Kind switch
|
|
{
|
|
PrimitiveTypeKind.I64 or PrimitiveTypeKind.U64 => "l",
|
|
PrimitiveTypeKind.I32 or PrimitiveTypeKind.U32 => "w",
|
|
PrimitiveTypeKind.I16 => "sh",
|
|
PrimitiveTypeKind.I8 => "sb",
|
|
PrimitiveTypeKind.U16 => "uh",
|
|
PrimitiveTypeKind.U8 or PrimitiveTypeKind.Bool => "ub",
|
|
PrimitiveTypeKind.F64 => "d",
|
|
PrimitiveTypeKind.F32 => "s",
|
|
_ => throw new ArgumentOutOfRangeException()
|
|
},
|
|
_ => throw new NotSupportedException($"'{type}' type cannot be used as a function definition type")
|
|
},
|
|
_ => throw new UnreachableException()
|
|
};
|
|
}
|
|
|
|
private static void EmitFuncDefinition(BoundNode debugNode, string name, List<FuncParameter> parameters, NubType returnType, BoundBlock body, bool exported)
|
|
{
|
|
_variables.Clear();
|
|
_variableScopes.Clear();
|
|
_labelIndex = 0;
|
|
_tmpIndex = 0;
|
|
|
|
var builder = new StringBuilder();
|
|
|
|
if (exported)
|
|
{
|
|
builder.Append("export ");
|
|
}
|
|
|
|
builder.Append("function ");
|
|
if (returnType is not NubVoidType)
|
|
{
|
|
builder.Append(FuncQBETypeName(returnType) + ' ');
|
|
}
|
|
|
|
builder.Append(name);
|
|
|
|
var parameterStrings = parameters.Select(x => FuncQBETypeName(x.Type) + $" %{x.Name}");
|
|
|
|
builder.Append($"({string.Join(", ", parameterStrings)})");
|
|
|
|
_writer.StartFunction(builder.ToString());
|
|
_writer.WriteDebugLocation(debugNode);
|
|
|
|
var parameterVars = parameters.Select(parameter => new Variable(parameter.Name, new Val("%" + parameter.Name, parameter.Type, ValKind.Direct))).ToList();
|
|
|
|
EmitBlock(body, parameterVars);
|
|
|
|
if (body.Statements.LastOrDefault() is not BoundReturnNode)
|
|
{
|
|
if (returnType is NubVoidType)
|
|
{
|
|
_writer.Indented("ret");
|
|
}
|
|
}
|
|
|
|
_writer.EndFunction();
|
|
}
|
|
|
|
private static void EmitStructDefinition(BoundStructDefinitionNode structDef)
|
|
{
|
|
var structType = new NubCustomType(structDef.Namespace, structDef.Name);
|
|
_writer.WriteLine($"type {CustomTypeName(structType)} = {{ ");
|
|
|
|
var types = new Dictionary<string, string>();
|
|
|
|
foreach (var field in structDef.Fields)
|
|
{
|
|
types.Add(field.Name, StructDefQBEType(field));
|
|
}
|
|
|
|
var longest = types.Values.Max(x => x.Length);
|
|
foreach (var (name, type) in types)
|
|
{
|
|
var padding = longest - type.Length;
|
|
_writer.Indented($"{type},{new string(' ', padding)} # {name}");
|
|
}
|
|
|
|
_writer.WriteLine("}");
|
|
return;
|
|
|
|
string StructDefQBEType(BoundStructField field)
|
|
{
|
|
return field.Type switch
|
|
{
|
|
NubCustomType customType => CustomTypeName(customType),
|
|
NubComplexType => "l",
|
|
NubSimpleType simpleType => simpleType switch
|
|
{
|
|
NubPointerType or NubFuncType => "l",
|
|
NubPrimitiveType primitiveType => primitiveType.Kind switch
|
|
{
|
|
PrimitiveTypeKind.I64 or PrimitiveTypeKind.U64 => "l",
|
|
PrimitiveTypeKind.I32 or PrimitiveTypeKind.U32 => "w",
|
|
PrimitiveTypeKind.I16 or PrimitiveTypeKind.U16 => "h",
|
|
PrimitiveTypeKind.I8 or PrimitiveTypeKind.U8 or PrimitiveTypeKind.Bool => "b",
|
|
PrimitiveTypeKind.F64 => "d",
|
|
PrimitiveTypeKind.F32 => "s",
|
|
_ => throw new ArgumentOutOfRangeException()
|
|
},
|
|
_ => throw new NotSupportedException($"'{field.Type}' type cannot be used in structs")
|
|
},
|
|
_ => throw new UnreachableException()
|
|
};
|
|
}
|
|
}
|
|
|
|
private static void EmitTraitVTable(BoundTraitDefinitionNode traitDef)
|
|
{
|
|
_writer.WriteLine($"type {CustomTypeName(new NubCustomType(traitDef.Namespace, traitDef.Name))} = {{");
|
|
|
|
foreach (var func in traitDef.Functions)
|
|
{
|
|
_writer.Indented($"l, # func {func.Name}({string.Join(", ", func.Parameters.Select(x => $"{x.Name}: {x.Type}"))}): {func.ReturnType}");
|
|
}
|
|
|
|
_writer.WriteLine("}");
|
|
}
|
|
|
|
private static void EmitStatement(BoundStatementNode statement)
|
|
{
|
|
_writer.WriteDebugLocation(statement);
|
|
|
|
switch (statement)
|
|
{
|
|
case BoundAssignmentNode assignment:
|
|
EmitAssignment(assignment);
|
|
break;
|
|
case BoundBreakNode @break:
|
|
EmitBreak(@break);
|
|
break;
|
|
case BoundContinueNode @continue:
|
|
EmitContinue(@continue);
|
|
break;
|
|
case BoundIfNode ifStatement:
|
|
EmitIf(ifStatement);
|
|
break;
|
|
case BoundReturnNode @return:
|
|
EmitReturn(@return);
|
|
break;
|
|
case BoundStatementExpressionNode statementExpression:
|
|
EmitExpression(statementExpression.Expression);
|
|
break;
|
|
case BoundVariableDeclarationNode variableDeclaration:
|
|
EmitVariableDeclaration(variableDeclaration);
|
|
break;
|
|
case BoundWhileNode whileStatement:
|
|
EmitWhile(whileStatement);
|
|
break;
|
|
default:
|
|
throw new ArgumentOutOfRangeException(nameof(statement));
|
|
}
|
|
}
|
|
|
|
private static void EmitAssignment(BoundAssignmentNode assignment)
|
|
{
|
|
var destination = EmitExpression(assignment.Expression);
|
|
Debug.Assert(destination.Kind == ValKind.Pointer);
|
|
EmitCopyIntoOrInitialize(assignment.Value, destination.Name);
|
|
}
|
|
|
|
private static void EmitBlock(BoundBlock block, List<Variable>? variables = null)
|
|
{
|
|
_variableScopes.Push(_variables.Count);
|
|
if (variables != null)
|
|
{
|
|
foreach (var variable in variables)
|
|
{
|
|
_variables.Push(variable);
|
|
}
|
|
}
|
|
|
|
foreach (var statement in block.Statements.Where(_ => _codeIsReachable))
|
|
{
|
|
EmitStatement(statement);
|
|
}
|
|
|
|
var count = _variableScopes.Pop();
|
|
while (_variableScopes.Count > count)
|
|
{
|
|
_variableScopes.Pop();
|
|
}
|
|
|
|
_codeIsReachable = true;
|
|
}
|
|
|
|
private static void EmitBreak(BoundBreakNode @break)
|
|
{
|
|
_writer.Indented($"jmp {_breakLabels.Peek()}");
|
|
_codeIsReachable = false;
|
|
}
|
|
|
|
private static void EmitContinue(BoundContinueNode @continue)
|
|
{
|
|
_writer.Indented($"jmp {_continueLabels.Peek()}");
|
|
_codeIsReachable = false;
|
|
}
|
|
|
|
private static void EmitIf(BoundIfNode ifStatement)
|
|
{
|
|
var trueLabel = LabelName();
|
|
var falseLabel = LabelName();
|
|
var endLabel = LabelName();
|
|
|
|
var result = EmitUnwrap(EmitExpression(ifStatement.Condition));
|
|
_writer.Indented($"jnz {result}, {trueLabel}, {falseLabel}");
|
|
_writer.WriteLine(trueLabel);
|
|
EmitBlock(ifStatement.Body);
|
|
_writer.Indented($"jmp {endLabel}");
|
|
_writer.WriteLine(falseLabel);
|
|
if (ifStatement.Else.HasValue)
|
|
{
|
|
ifStatement.Else.Value.Match
|
|
(
|
|
elseIfNode => EmitIf(elseIfNode),
|
|
elseNode => EmitBlock(elseNode)
|
|
);
|
|
}
|
|
|
|
_writer.WriteLine(endLabel);
|
|
}
|
|
|
|
private static void EmitReturn(BoundReturnNode @return)
|
|
{
|
|
if (@return.Value.HasValue)
|
|
{
|
|
var result = EmitUnwrap(EmitExpression(@return.Value.Value));
|
|
_writer.Indented($"ret {result}");
|
|
}
|
|
else
|
|
{
|
|
_writer.Indented("ret");
|
|
}
|
|
}
|
|
|
|
private static void EmitVariableDeclaration(BoundVariableDeclarationNode variableDeclaration)
|
|
{
|
|
var name = $"%{variableDeclaration.Name}";
|
|
_writer.Indented($"{name} =l alloc8 8");
|
|
|
|
if (variableDeclaration.Assignment.HasValue)
|
|
{
|
|
var value = EmitCreateCopyOrInitialize(variableDeclaration.Assignment.Value);
|
|
EmitStore(variableDeclaration.Assignment.Value.Type, value, name);
|
|
}
|
|
|
|
_variables.Push(new Variable(variableDeclaration.Name, new Val(name, variableDeclaration.Type, ValKind.Pointer)));
|
|
}
|
|
|
|
private static void EmitWhile(BoundWhileNode whileStatement)
|
|
{
|
|
var conditionLabel = LabelName();
|
|
var iterationLabel = LabelName();
|
|
var endLabel = LabelName();
|
|
|
|
_breakLabels.Push(endLabel);
|
|
_continueLabels.Push(conditionLabel);
|
|
|
|
_writer.Indented($"jmp {conditionLabel}");
|
|
_writer.WriteLine(iterationLabel);
|
|
EmitBlock(whileStatement.Body);
|
|
_writer.WriteLine(conditionLabel);
|
|
var result = EmitUnwrap(EmitExpression(whileStatement.Condition));
|
|
_writer.Indented($"jnz {result}, {iterationLabel}, {endLabel}");
|
|
_writer.WriteLine(endLabel);
|
|
|
|
_continueLabels.Pop();
|
|
_breakLabels.Pop();
|
|
}
|
|
|
|
private static Val EmitExpression(BoundExpressionNode expression)
|
|
{
|
|
_writer.WriteDebugLocation(expression);
|
|
return expression switch
|
|
{
|
|
BoundAddressOfNode addressOf => EmitAddressOf(addressOf),
|
|
BoundAnonymousFuncNode anonymousFunc => EmitAnonymousFunc(anonymousFunc),
|
|
BoundArrayIndexAccessNode arrayIndex => EmitArrayIndexAccess(arrayIndex),
|
|
BoundArrayInitializerNode arrayInitializer => EmitArrayInitializer(arrayInitializer),
|
|
BoundBinaryExpressionNode binaryExpression => EmitBinaryExpression(binaryExpression),
|
|
BoundDereferenceNode dereference => EmitDereference(dereference),
|
|
BoundFuncCallNode funcCallExpression => EmitFuncCall(funcCallExpression),
|
|
BoundIdentifierNode identifier => EmitIdentifier(identifier),
|
|
BoundLiteralNode literal => EmitLiteral(literal),
|
|
BoundStructInitializerNode structInitializer => EmitStructInitializer(structInitializer),
|
|
BoundUnaryExpressionNode unaryExpression => EmitUnaryExpression(unaryExpression),
|
|
BoundMemberAccessNode memberAccess => EmitMemberAccess(memberAccess),
|
|
_ => throw new ArgumentOutOfRangeException(nameof(expression))
|
|
};
|
|
}
|
|
|
|
private static Val EmitAnonymousFunc(BoundAnonymousFuncNode anonymousFunc)
|
|
{
|
|
var name = $"$anon_func{++_anonymousFuncIndex}";
|
|
_anonymousFunctions.Enqueue((anonymousFunc, name));
|
|
return new Val(name, anonymousFunc.Type, ValKind.Direct);
|
|
}
|
|
|
|
private static Val EmitArrayIndexAccess(BoundArrayIndexAccessNode arrayIndexAccess)
|
|
{
|
|
var array = EmitUnwrap(EmitExpression(arrayIndexAccess.Array));
|
|
var index = EmitUnwrap(EmitExpression(arrayIndexAccess.Index));
|
|
|
|
var elementType = ((NubArrayType)arrayIndexAccess.Array.Type).ElementType;
|
|
|
|
var pointer = TmpName();
|
|
_writer.Indented($"{pointer} =l mul {index}, {SizeOf(elementType)}");
|
|
_writer.Indented($"{pointer} =l add {pointer}, 8");
|
|
_writer.Indented($"{pointer} =l add {array}, {pointer}");
|
|
return new Val(pointer, arrayIndexAccess.Type, ValKind.Pointer);
|
|
}
|
|
|
|
private static void EmitArrayBoundsCheck(string array, string index)
|
|
{
|
|
var count = TmpName();
|
|
_writer.Indented($"{count} =l loadl {array}");
|
|
|
|
var isNegative = TmpName();
|
|
_writer.Indented($"{isNegative} =w csltl {index}, 0");
|
|
|
|
var isOob = TmpName();
|
|
_writer.Indented($"{isOob} =w csgel {index}, {count}");
|
|
|
|
var anyOob = TmpName();
|
|
_writer.Indented($"{anyOob} =w or {isNegative}, {isOob}");
|
|
|
|
var oobLabel = LabelName();
|
|
var notOobLabel = LabelName();
|
|
_writer.Indented($"jnz {anyOob}, {oobLabel}, {notOobLabel}");
|
|
|
|
_writer.Indented(oobLabel);
|
|
_writer.Indented($"call $nub_panic_array_oob()");
|
|
|
|
_writer.Indented(notOobLabel);
|
|
}
|
|
|
|
private static Val EmitArrayInitializer(BoundArrayInitializerNode arrayInitializer)
|
|
{
|
|
var capacity = EmitUnwrap(EmitExpression(arrayInitializer.Capacity));
|
|
var elementSize = SizeOf(arrayInitializer.ElementType);
|
|
|
|
var capacityInBytes = TmpName();
|
|
_writer.Indented($"{capacityInBytes} =l mul {capacity}, {elementSize}");
|
|
var totalSize = TmpName();
|
|
_writer.Indented($"{totalSize} =l add {capacityInBytes}, 8");
|
|
|
|
var arrayPointer = TmpName();
|
|
_writer.Indented($"{arrayPointer} =l alloc8 {totalSize}");
|
|
_writer.Indented($"storel {capacity}, {arrayPointer}");
|
|
|
|
var dataPointer = TmpName();
|
|
_writer.Indented($"{dataPointer} =l add {arrayPointer}, 8");
|
|
_writer.Indented($"call $nub_memset(l {dataPointer}, w 0, l {capacityInBytes})");
|
|
|
|
return new Val(arrayPointer, arrayInitializer.Type, ValKind.Direct);
|
|
}
|
|
|
|
private static Val EmitDereference(BoundDereferenceNode dereference)
|
|
{
|
|
return EmitLoad(dereference.Type, EmitUnwrap(EmitExpression(dereference.Expression)));
|
|
}
|
|
|
|
private static Val EmitAddressOf(BoundAddressOfNode addressOf)
|
|
{
|
|
var value = EmitExpression(addressOf.Expression);
|
|
Debug.Assert(value.Kind == ValKind.Pointer);
|
|
return new Val(value.Name, addressOf.Type, ValKind.Direct);
|
|
}
|
|
|
|
private static Val EmitBinaryExpression(BoundBinaryExpressionNode binaryExpression)
|
|
{
|
|
var left = EmitUnwrap(EmitExpression(binaryExpression.Left));
|
|
var right = EmitUnwrap(EmitExpression(binaryExpression.Right));
|
|
|
|
var outputName = TmpName();
|
|
|
|
var instruction = EmitBinaryInstructionFor(binaryExpression.Operator, binaryExpression.Left.Type, left, right);
|
|
|
|
_writer.Indented($"{outputName} {QBEAssign(binaryExpression.Left.Type)} {instruction} {left}, {right}");
|
|
return new Val(outputName, binaryExpression.Type, ValKind.Direct);
|
|
}
|
|
|
|
private static string EmitBinaryInstructionFor(BinaryExpressionOperator op, NubType type, string left, string right)
|
|
{
|
|
if (op is
|
|
BinaryExpressionOperator.Equal or
|
|
BinaryExpressionOperator.NotEqual or
|
|
BinaryExpressionOperator.GreaterThan or
|
|
BinaryExpressionOperator.GreaterThanOrEqual or
|
|
BinaryExpressionOperator.LessThan or
|
|
BinaryExpressionOperator.LessThanOrEqual)
|
|
{
|
|
char suffix;
|
|
|
|
if (type.Is8BitInteger)
|
|
{
|
|
if (type.IsSignedInteger)
|
|
{
|
|
_writer.Indented($"{left} =w extsb {left}");
|
|
_writer.Indented($"{right} =w extsb {right}");
|
|
}
|
|
else
|
|
{
|
|
_writer.Indented($"{left} =w extub {left}");
|
|
_writer.Indented($"{right} =w extub {right}");
|
|
}
|
|
|
|
suffix = 'w';
|
|
}
|
|
else if (type.Is16BitInteger)
|
|
{
|
|
if (type.IsSignedInteger)
|
|
{
|
|
_writer.Indented($"{left} =w extsh {left}");
|
|
_writer.Indented($"{right} =w extsh {right}");
|
|
}
|
|
else
|
|
{
|
|
_writer.Indented($"{left} =w extuh {left}");
|
|
_writer.Indented($"{right} =w extuh {right}");
|
|
}
|
|
|
|
suffix = 'w';
|
|
}
|
|
else if (type.Is32BitInteger)
|
|
{
|
|
suffix = 'w';
|
|
}
|
|
else if (type.Is64BitInteger)
|
|
{
|
|
suffix = 'l';
|
|
}
|
|
else
|
|
{
|
|
throw new NotSupportedException($"Unsupported type '{type}' for binary operator '{op}'");
|
|
}
|
|
|
|
if (op is BinaryExpressionOperator.Equal)
|
|
{
|
|
return "ceq" + suffix;
|
|
}
|
|
|
|
if (op is BinaryExpressionOperator.NotEqual)
|
|
{
|
|
return "cne" + suffix;
|
|
}
|
|
|
|
string sign;
|
|
|
|
if (type.IsSignedInteger)
|
|
{
|
|
sign = "s";
|
|
}
|
|
else if (type.IsUnsignedInteger)
|
|
{
|
|
sign = "u";
|
|
}
|
|
else if (type.IsFloat)
|
|
{
|
|
sign = "";
|
|
}
|
|
else
|
|
{
|
|
throw new NotSupportedException($"Unsupported type '{type}' for binary operator '{op}'");
|
|
}
|
|
|
|
return op switch
|
|
{
|
|
BinaryExpressionOperator.GreaterThan => 'c' + sign + "gt" + suffix,
|
|
BinaryExpressionOperator.GreaterThanOrEqual => 'c' + sign + "ge" + suffix,
|
|
BinaryExpressionOperator.LessThan => 'c' + sign + "lt" + suffix,
|
|
BinaryExpressionOperator.LessThanOrEqual => 'c' + sign + "le" + suffix,
|
|
_ => throw new ArgumentOutOfRangeException(nameof(op), op, null)
|
|
};
|
|
}
|
|
|
|
return op switch
|
|
{
|
|
BinaryExpressionOperator.Plus => "add",
|
|
BinaryExpressionOperator.Minus => "sub",
|
|
BinaryExpressionOperator.Multiply => "mul",
|
|
BinaryExpressionOperator.Divide => "div",
|
|
_ => throw new ArgumentOutOfRangeException(nameof(op))
|
|
};
|
|
}
|
|
|
|
private static Val EmitIdentifier(BoundIdentifierNode identifier)
|
|
{
|
|
if (_definitionTable.LookupFunc(identifier.Namespace.Or(_syntaxTree.Namespace), identifier.Name).TryGetValue(out var func))
|
|
{
|
|
return new Val(FuncName(func), identifier.Type, ValKind.Direct);
|
|
}
|
|
|
|
if (!identifier.Namespace.HasValue)
|
|
{
|
|
return _variables.Single(v => v.Name == identifier.Name).Val;
|
|
}
|
|
|
|
throw new UnreachableException();
|
|
}
|
|
|
|
private static Val EmitLiteral(BoundLiteralNode literal)
|
|
{
|
|
switch (literal.Kind)
|
|
{
|
|
case LiteralKind.Integer:
|
|
{
|
|
if (literal.Type.IsFloat32)
|
|
{
|
|
var value = float.Parse(literal.Literal, CultureInfo.InvariantCulture);
|
|
var bits = BitConverter.SingleToInt32Bits(value);
|
|
return new Val(bits.ToString(), literal.Type, ValKind.Direct);
|
|
}
|
|
|
|
if (literal.Type.IsFloat64)
|
|
{
|
|
var value = double.Parse(literal.Literal, CultureInfo.InvariantCulture);
|
|
var bits = BitConverter.DoubleToInt64Bits(value);
|
|
return new Val(bits.ToString(), literal.Type, ValKind.Direct);
|
|
}
|
|
|
|
if (literal.Type.IsInteger)
|
|
{
|
|
return new Val(literal.Literal, literal.Type, ValKind.Direct);
|
|
}
|
|
|
|
break;
|
|
}
|
|
case LiteralKind.Float:
|
|
{
|
|
if (literal.Type.IsInteger)
|
|
{
|
|
return new Val(literal.Literal.Split(".").First(), literal.Type, ValKind.Direct);
|
|
}
|
|
|
|
if (literal.Type.IsFloat32)
|
|
{
|
|
var value = float.Parse(literal.Literal, CultureInfo.InvariantCulture);
|
|
var bits = BitConverter.SingleToInt32Bits(value);
|
|
return new Val(bits.ToString(), literal.Type, ValKind.Direct);
|
|
}
|
|
|
|
if (literal.Type.IsFloat64)
|
|
{
|
|
var value = double.Parse(literal.Literal, CultureInfo.InvariantCulture);
|
|
var bits = BitConverter.DoubleToInt64Bits(value);
|
|
return new Val(bits.ToString(), literal.Type, ValKind.Direct);
|
|
}
|
|
|
|
break;
|
|
}
|
|
case LiteralKind.String:
|
|
{
|
|
if (literal.Type.IsString)
|
|
{
|
|
var stringLiteral = new StringLiteral(literal.Literal, StringName());
|
|
_stringLiterals.Add(stringLiteral);
|
|
return new Val(stringLiteral.Name, literal.Type, ValKind.Direct);
|
|
}
|
|
|
|
if (literal.Type.IsCString)
|
|
{
|
|
var cStringLiteral = new CStringLiteral(literal.Literal, CStringName());
|
|
_cStringLiterals.Add(cStringLiteral);
|
|
return new Val(cStringLiteral.Name, literal.Type, ValKind.Direct);
|
|
}
|
|
|
|
break;
|
|
}
|
|
case LiteralKind.Bool:
|
|
{
|
|
if (literal.Type.IsBool)
|
|
{
|
|
return new Val(bool.Parse(literal.Literal) ? "1" : "0", literal.Type, ValKind.Direct);
|
|
}
|
|
|
|
break;
|
|
}
|
|
}
|
|
|
|
throw new NotSupportedException($"Cannot create literal of kind '{literal.Kind}' for type {literal.Type}");
|
|
}
|
|
|
|
private static Val EmitStructInitializer(BoundStructInitializerNode structInitializer, string? destination = null)
|
|
{
|
|
if (structInitializer.StructType is not NubCustomType structType)
|
|
{
|
|
throw new UnreachableException();
|
|
}
|
|
|
|
var structDefinition = _definitionTable.LookupStruct(structType.Namespace, structType.Name).GetValue();
|
|
|
|
if (destination == null)
|
|
{
|
|
destination = TmpName();
|
|
var size = SizeOf(structType);
|
|
_writer.Indented($"{destination} =l alloc8 {size}");
|
|
}
|
|
|
|
foreach (var field in structDefinition.Fields)
|
|
{
|
|
if (!structInitializer.Initializers.TryGetValue(field.Name, out var valueExpression))
|
|
{
|
|
valueExpression = field.Value.Value;
|
|
}
|
|
|
|
Debug.Assert(valueExpression != null);
|
|
|
|
var offset = TmpName();
|
|
_writer.Indented($"{offset} =l add {destination}, {OffsetOf(structDefinition, field.Name)}");
|
|
EmitCopyIntoOrInitialize(valueExpression, offset);
|
|
}
|
|
|
|
return new Val(destination, structType, ValKind.Direct);
|
|
}
|
|
|
|
private static Val EmitUnaryExpression(BoundUnaryExpressionNode unaryExpression)
|
|
{
|
|
var operand = EmitUnwrap(EmitExpression(unaryExpression.Operand));
|
|
var outputName = TmpName();
|
|
|
|
switch (unaryExpression.Operator)
|
|
{
|
|
case UnaryExpressionOperator.Negate:
|
|
{
|
|
switch (unaryExpression.Operand.Type)
|
|
{
|
|
case NubPrimitiveType { Kind: PrimitiveTypeKind.I64 }:
|
|
_writer.Indented($"{outputName} =l neg {operand}");
|
|
return new Val(outputName, unaryExpression.Type, ValKind.Direct);
|
|
case NubPrimitiveType { Kind: PrimitiveTypeKind.I32 or PrimitiveTypeKind.I16 or PrimitiveTypeKind.I8 }:
|
|
_writer.Indented($"{outputName} =w neg {operand}");
|
|
return new Val(outputName, unaryExpression.Type, ValKind.Direct);
|
|
case NubPrimitiveType { Kind: PrimitiveTypeKind.F64 }:
|
|
_writer.Indented($"{outputName} =d neg {operand}");
|
|
return new Val(outputName, unaryExpression.Type, ValKind.Direct);
|
|
case NubPrimitiveType { Kind: PrimitiveTypeKind.F32 }:
|
|
_writer.Indented($"{outputName} =s neg {operand}");
|
|
return new Val(outputName, unaryExpression.Type, ValKind.Direct);
|
|
}
|
|
|
|
break;
|
|
}
|
|
case UnaryExpressionOperator.Invert:
|
|
{
|
|
switch (unaryExpression.Operand.Type)
|
|
{
|
|
case NubPrimitiveType { Kind: PrimitiveTypeKind.Bool }:
|
|
_writer.Indented($"{outputName} =w xor {operand}, 1");
|
|
return new Val(outputName, unaryExpression.Type, ValKind.Direct);
|
|
}
|
|
|
|
break;
|
|
}
|
|
default:
|
|
{
|
|
throw new ArgumentOutOfRangeException();
|
|
}
|
|
}
|
|
|
|
throw new NotSupportedException($"Unary operator {unaryExpression.Operator} for type {unaryExpression.Operand.Type} not supported");
|
|
}
|
|
|
|
private static Val EmitMemberAccess(BoundMemberAccessNode memberAccess)
|
|
{
|
|
var item = EmitUnwrap(EmitExpression(memberAccess.Expression));
|
|
|
|
var implementation = _definitionTable.LookupTraitImplementationForType(memberAccess.Expression.Type, memberAccess.Member);
|
|
if (implementation.HasValue)
|
|
{
|
|
var name = ImplFuncName(implementation.Value.Item1, memberAccess.Member);
|
|
_implFunctions.TryAdd(implementation.Value.Item2, name);
|
|
return new Val(name, memberAccess.Type, ValKind.Direct, new MethodCallContext(item, memberAccess.Expression.Type));
|
|
}
|
|
|
|
var output = TmpName();
|
|
|
|
if (memberAccess.Expression.Type is NubCustomType customType)
|
|
{
|
|
var function = _definitionTable.LookupFunctionOnTrait(customType.Namespace, customType.Name, memberAccess.Member);
|
|
if (function.HasValue)
|
|
{
|
|
throw new NotImplementedException("VTable lookup is not implemented");
|
|
}
|
|
|
|
var structDef = _definitionTable.LookupStruct(customType.Namespace, customType.Name);
|
|
if (structDef.HasValue)
|
|
{
|
|
var offset = OffsetOf(structDef.Value, memberAccess.Member);
|
|
_writer.Indented($"{output} =l add {item}, {offset}");
|
|
|
|
if (memberAccess.Type is NubCustomType inner)
|
|
{
|
|
// If the accessed member is an inline struct, it will not be a pointer
|
|
if (_definitionTable.LookupStruct(inner.Namespace, inner.Name).HasValue)
|
|
{
|
|
return new Val(output, memberAccess.Type, ValKind.Direct);
|
|
}
|
|
}
|
|
|
|
return new Val(output, memberAccess.Type, ValKind.Pointer);
|
|
}
|
|
}
|
|
|
|
if (memberAccess.Member == "count")
|
|
{
|
|
switch (memberAccess.Expression.Type)
|
|
{
|
|
case NubArrayType:
|
|
{
|
|
_writer.Indented($"{output} =l loadl {item}");
|
|
return new Val(output, memberAccess.Type, ValKind.Direct);
|
|
}
|
|
case NubStringType:
|
|
{
|
|
_writer.Indented($"{output} =l call $nub_string_length(l {item})");
|
|
return new Val(output, memberAccess.Type, ValKind.Direct);
|
|
}
|
|
case NubCStringType:
|
|
{
|
|
_writer.Indented($"{output} =l call $nub_cstring_length(l {item})");
|
|
return new Val(output, memberAccess.Type, ValKind.Direct);
|
|
}
|
|
}
|
|
}
|
|
|
|
throw new UnreachableException();
|
|
}
|
|
|
|
private static Val EmitFuncCall(BoundFuncCallNode funcCall)
|
|
{
|
|
var expression = EmitExpression(funcCall.Expression);
|
|
var funcPointer = EmitUnwrap(expression);
|
|
|
|
var parameterStrings = new List<string>();
|
|
|
|
if (expression.FuncCallContext != null)
|
|
{
|
|
parameterStrings.Add($"{FuncQBETypeName(expression.FuncCallContext.ThisArgType)} {expression.FuncCallContext.ThisArgName}");
|
|
}
|
|
|
|
foreach (var parameter in funcCall.Parameters)
|
|
{
|
|
var copy = EmitCreateCopyOrInitialize(parameter);
|
|
parameterStrings.Add($"{FuncQBETypeName(parameter.Type)} {copy}");
|
|
}
|
|
|
|
if (funcCall.Type.IsVoid)
|
|
{
|
|
_writer.Indented($"call {funcPointer}({string.Join(", ", parameterStrings)})");
|
|
return new Val(string.Empty, funcCall.Type, ValKind.Direct);
|
|
}
|
|
else
|
|
{
|
|
var outputName = TmpName();
|
|
_writer.Indented($"{outputName} {QBEAssign(funcCall.Type)} call {funcPointer}({string.Join(", ", parameterStrings)})");
|
|
return new Val(outputName, funcCall.Type, ValKind.Direct);
|
|
}
|
|
}
|
|
|
|
private static string EmitUnwrap(Val val)
|
|
{
|
|
return val.Kind switch
|
|
{
|
|
ValKind.Direct => val.Name,
|
|
ValKind.Pointer => EmitLoad(val.Type, val.Name).Name,
|
|
_ => throw new ArgumentOutOfRangeException()
|
|
};
|
|
}
|
|
}
|
|
|
|
internal class StringLiteral(string value, string name)
|
|
{
|
|
public string Value { get; } = value;
|
|
public string Name { get; } = name;
|
|
}
|
|
|
|
internal class CStringLiteral(string value, string name)
|
|
{
|
|
public string Value { get; } = value;
|
|
public string Name { get; } = name;
|
|
}
|
|
|
|
internal class Variable(string name, Val val)
|
|
{
|
|
public string Name { get; } = name;
|
|
public Val Val { get; } = val;
|
|
}
|
|
|
|
internal record Val(string Name, NubType Type, ValKind Kind, MethodCallContext? FuncCallContext = null);
|
|
|
|
internal record MethodCallContext(string ThisArgName, NubType ThisArgType);
|
|
|
|
internal enum ValKind
|
|
{
|
|
Pointer,
|
|
Direct,
|
|
} |