....
This commit is contained in:
nub31
467
src/compiler/NubLang/Generation/QBE/QBEGenerator.Expression.cs
Normal file
467
src/compiler/NubLang/Generation/QBE/QBEGenerator.Expression.cs
Normal file
@@ -0,0 +1,467 @@
|
||||
using System.Diagnostics;
|
||||
using System.Globalization;
|
||||
using NubLang.Syntax.Binding.Node;
|
||||
using NubLang.Syntax.Tokenization;
|
||||
|
||||
namespace NubLang.Generation.QBE;
|
||||
|
||||
public partial class QBEGenerator
|
||||
{
|
||||
private Val EmitExpression(BoundExpression expression)
|
||||
{
|
||||
_writer.WriteDebugLocation(expression);
|
||||
|
||||
return expression switch
|
||||
{
|
||||
BoundArrayInitializer arrayInitializer => EmitArrayInitializer(arrayInitializer),
|
||||
BoundStructInitializer structInitializer => EmitStructInitializer(structInitializer),
|
||||
BoundAddressOf addressOf => EmitAddressOf(addressOf),
|
||||
BoundDereference dereference => EmitDereference(dereference),
|
||||
BoundAnonymousFunc anonymousFunc => EmitAnonymousFunc(anonymousFunc),
|
||||
BoundBinaryExpression binaryExpression => EmitBinaryExpression(binaryExpression),
|
||||
BoundFuncCall funcCallExpression => EmitFuncCall(funcCallExpression),
|
||||
BoundExternFuncIdent externFuncIdent => EmitExternFuncIdent(externFuncIdent),
|
||||
BoundLocalFuncIdent localFuncIdent => EmitLocalFuncIdent(localFuncIdent),
|
||||
BoundVariableIdent variableIdent => EmitVariableIdent(variableIdent),
|
||||
BoundLiteral literal => EmitLiteral(literal),
|
||||
BoundUnaryExpression unaryExpression => EmitUnaryExpression(unaryExpression),
|
||||
BoundStructFieldAccess structFieldAccess => EmitStructFieldAccess(structFieldAccess),
|
||||
BoundTraitFuncAccess traitFuncAccess => EmitTraitFuncAccess(traitFuncAccess),
|
||||
BoundTraitImplFuncAccess traitImplFuncAccess => EmitTraitImplFuncAccess(traitImplFuncAccess),
|
||||
BoundArrayIndexAccess arrayIndex => EmitArrayIndexAccess(arrayIndex),
|
||||
_ => throw new ArgumentOutOfRangeException(nameof(expression))
|
||||
};
|
||||
}
|
||||
|
||||
private Val EmitAnonymousFunc(BoundAnonymousFunc anonymousFunc)
|
||||
{
|
||||
var name = $"$anon_func{++_anonymousFuncIndex}";
|
||||
_anonymousFunctions.Enqueue((anonymousFunc, name));
|
||||
return new Val(name, anonymousFunc.Type, ValKind.Direct);
|
||||
}
|
||||
|
||||
private Val EmitArrayIndexAccess(BoundArrayIndexAccess arrayIndexAccess)
|
||||
{
|
||||
var array = EmitUnwrap(EmitExpression(arrayIndexAccess.Target));
|
||||
var index = EmitUnwrap(EmitExpression(arrayIndexAccess.Index));
|
||||
|
||||
EmitArrayBoundsCheck(array, index);
|
||||
|
||||
var elementType = ((NubArrayType)arrayIndexAccess.Target.Type).ElementType;
|
||||
|
||||
var pointer = TmpName();
|
||||
_writer.Indented($"{pointer} =l mul {index}, {elementType.Size(_definitionTable)}");
|
||||
_writer.Indented($"{pointer} =l add {pointer}, 8");
|
||||
_writer.Indented($"{pointer} =l add {array}, {pointer}");
|
||||
return new Val(pointer, arrayIndexAccess.Type, ValKind.Pointer);
|
||||
}
|
||||
|
||||
private 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 Val EmitArrayInitializer(BoundArrayInitializer arrayInitializer)
|
||||
{
|
||||
var capacity = EmitUnwrap(EmitExpression(arrayInitializer.Capacity));
|
||||
var elementSize = arrayInitializer.ElementType.Size(_definitionTable);
|
||||
|
||||
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 Val EmitDereference(BoundDereference dereference)
|
||||
{
|
||||
return EmitLoad(dereference.Type, EmitUnwrap(EmitExpression(dereference.Expression)));
|
||||
}
|
||||
|
||||
private Val EmitAddressOf(BoundAddressOf addressOf)
|
||||
{
|
||||
var value = EmitExpression(addressOf.Expression);
|
||||
if (value.Kind != ValKind.Pointer)
|
||||
{
|
||||
throw new UnreachableException("Tried to take address of non-pointer type. This should have been causht in the type checker");
|
||||
}
|
||||
|
||||
return new Val(value.Name, addressOf.Type, ValKind.Direct);
|
||||
}
|
||||
|
||||
private Val EmitBinaryExpression(BoundBinaryExpression 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 string EmitBinaryInstructionFor(BoundBinaryOperator op, NubType type, string left, string right)
|
||||
{
|
||||
if (op is
|
||||
BoundBinaryOperator.Equal or
|
||||
BoundBinaryOperator.NotEqual or
|
||||
BoundBinaryOperator.GreaterThan or
|
||||
BoundBinaryOperator.GreaterThanOrEqual or
|
||||
BoundBinaryOperator.LessThan or
|
||||
BoundBinaryOperator.LessThanOrEqual)
|
||||
{
|
||||
char suffix;
|
||||
|
||||
if (!type.IsSimpleType(out var simpleType, out _))
|
||||
{
|
||||
throw new NotSupportedException("Binary operations is only supported for simple types.");
|
||||
}
|
||||
|
||||
switch (simpleType.StorageSize)
|
||||
{
|
||||
case StorageSize.I8:
|
||||
_writer.Indented($"{left} =w extsb {left}");
|
||||
_writer.Indented($"{right} =w extsb {right}");
|
||||
suffix = 'w';
|
||||
break;
|
||||
case StorageSize.U8:
|
||||
_writer.Indented($"{left} =w extub {left}");
|
||||
_writer.Indented($"{right} =w extub {right}");
|
||||
suffix = 'w';
|
||||
break;
|
||||
case StorageSize.I16:
|
||||
_writer.Indented($"{left} =w extsh {left}");
|
||||
_writer.Indented($"{right} =w extsh {right}");
|
||||
suffix = 'w';
|
||||
break;
|
||||
case StorageSize.U16:
|
||||
_writer.Indented($"{left} =w extuh {left}");
|
||||
_writer.Indented($"{right} =w extuh {right}");
|
||||
suffix = 'w';
|
||||
break;
|
||||
case StorageSize.I32 or StorageSize.U32:
|
||||
suffix = 'w';
|
||||
break;
|
||||
case StorageSize.I64 or StorageSize.U64:
|
||||
suffix = 'l';
|
||||
break;
|
||||
default:
|
||||
throw new NotSupportedException($"Unsupported type '{simpleType}' for binary operator '{op}'");
|
||||
}
|
||||
|
||||
if (op is BoundBinaryOperator.Equal)
|
||||
{
|
||||
return "ceq" + suffix;
|
||||
}
|
||||
|
||||
if (op is BoundBinaryOperator.NotEqual)
|
||||
{
|
||||
return "cne" + suffix;
|
||||
}
|
||||
|
||||
string sign;
|
||||
|
||||
if (simpleType is NubPrimitiveType { Kind: PrimitiveTypeKind.I8 or PrimitiveTypeKind.I16 or PrimitiveTypeKind.I32 or PrimitiveTypeKind.I64 })
|
||||
{
|
||||
sign = "s";
|
||||
}
|
||||
else if (simpleType is NubPrimitiveType { Kind: PrimitiveTypeKind.U8 or PrimitiveTypeKind.U16 or PrimitiveTypeKind.U32 or PrimitiveTypeKind.U64 })
|
||||
{
|
||||
sign = "u";
|
||||
}
|
||||
else
|
||||
{
|
||||
throw new NotSupportedException($"Unsupported type '{type}' for binary operator '{op}'");
|
||||
}
|
||||
|
||||
return op switch
|
||||
{
|
||||
BoundBinaryOperator.GreaterThan => 'c' + sign + "gt" + suffix,
|
||||
BoundBinaryOperator.GreaterThanOrEqual => 'c' + sign + "ge" + suffix,
|
||||
BoundBinaryOperator.LessThan => 'c' + sign + "lt" + suffix,
|
||||
BoundBinaryOperator.LessThanOrEqual => 'c' + sign + "le" + suffix,
|
||||
_ => throw new ArgumentOutOfRangeException(nameof(op), op, null)
|
||||
};
|
||||
}
|
||||
|
||||
return op switch
|
||||
{
|
||||
BoundBinaryOperator.Plus => "add",
|
||||
BoundBinaryOperator.Minus => "sub",
|
||||
BoundBinaryOperator.Multiply => "mul",
|
||||
BoundBinaryOperator.Divide => "div",
|
||||
_ => throw new ArgumentOutOfRangeException(nameof(op))
|
||||
};
|
||||
}
|
||||
|
||||
private Val EmitExternFuncIdent(BoundExternFuncIdent externFuncIdent)
|
||||
{
|
||||
var func = _definitionTable.LookupExternFunc(externFuncIdent.Namespace, externFuncIdent.Name);
|
||||
return new Val(ExternFuncName(func), externFuncIdent.Type, ValKind.Direct);
|
||||
}
|
||||
|
||||
private Val EmitLocalFuncIdent(BoundLocalFuncIdent localFuncIdent)
|
||||
{
|
||||
var func = _definitionTable.LookupExternFunc(localFuncIdent.Namespace, localFuncIdent.Name);
|
||||
return new Val(ExternFuncName(func), localFuncIdent.Type, ValKind.Direct);
|
||||
}
|
||||
|
||||
private Val EmitVariableIdent(BoundVariableIdent variableIdent)
|
||||
{
|
||||
return _variables.Single(v => v.Name == variableIdent.Name).Val;
|
||||
}
|
||||
|
||||
private Val EmitLiteral(BoundLiteral literal)
|
||||
{
|
||||
switch (literal.Kind)
|
||||
{
|
||||
case LiteralKind.Integer:
|
||||
{
|
||||
if (literal.Type is NubPrimitiveType { Kind: PrimitiveTypeKind.F32 })
|
||||
{
|
||||
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 is NubPrimitiveType { Kind: PrimitiveTypeKind.F64 })
|
||||
{
|
||||
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 is NubPrimitiveType { Kind: PrimitiveTypeKind.I8 or PrimitiveTypeKind.U8 or PrimitiveTypeKind.I16 or PrimitiveTypeKind.U16 or PrimitiveTypeKind.I32 or PrimitiveTypeKind.U32 or PrimitiveTypeKind.I64 or PrimitiveTypeKind.U64 })
|
||||
{
|
||||
return new Val(literal.Literal, literal.Type, ValKind.Direct);
|
||||
}
|
||||
|
||||
break;
|
||||
}
|
||||
case LiteralKind.Float:
|
||||
{
|
||||
if (literal.Type is NubPrimitiveType { Kind: PrimitiveTypeKind.I8 or PrimitiveTypeKind.U8 or PrimitiveTypeKind.I16 or PrimitiveTypeKind.U16 or PrimitiveTypeKind.I32 or PrimitiveTypeKind.U32 or PrimitiveTypeKind.I64 or PrimitiveTypeKind.U64 })
|
||||
{
|
||||
return new Val(literal.Literal.Split(".").First(), literal.Type, ValKind.Direct);
|
||||
}
|
||||
|
||||
if (literal.Type is NubPrimitiveType { Kind: PrimitiveTypeKind.F32 })
|
||||
{
|
||||
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 is NubPrimitiveType { Kind: PrimitiveTypeKind.F64 })
|
||||
{
|
||||
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 is NubStringType)
|
||||
{
|
||||
var stringLiteral = new StringLiteral(literal.Literal, StringName());
|
||||
_stringLiterals.Add(stringLiteral);
|
||||
return new Val(stringLiteral.Name, literal.Type, ValKind.Direct);
|
||||
}
|
||||
|
||||
if (literal.Type is NubCStringType)
|
||||
{
|
||||
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 is NubPrimitiveType { Kind: PrimitiveTypeKind.Bool })
|
||||
{
|
||||
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 Val EmitStructInitializer(BoundStructInitializer structInitializer, string? destination = null)
|
||||
{
|
||||
var @struct = _definitionTable.LookupStruct(structInitializer.StructType.Namespace, structInitializer.StructType.Name);
|
||||
|
||||
if (destination == null)
|
||||
{
|
||||
destination = TmpName();
|
||||
var size = structInitializer.StructType.Size(_definitionTable);
|
||||
_writer.Indented($"{destination} =l alloc8 {size}");
|
||||
}
|
||||
|
||||
foreach (var field in @struct.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(@struct, field.Name)}");
|
||||
EmitCopyIntoOrInitialize(valueExpression, offset);
|
||||
}
|
||||
|
||||
return new Val(destination, structInitializer.StructType, ValKind.Direct);
|
||||
}
|
||||
|
||||
private Val EmitUnaryExpression(BoundUnaryExpression unaryExpression)
|
||||
{
|
||||
var operand = EmitUnwrap(EmitExpression(unaryExpression.Operand));
|
||||
var outputName = TmpName();
|
||||
|
||||
switch (unaryExpression.Operator)
|
||||
{
|
||||
case BoundUnaryOperator.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 BoundUnaryOperator.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 Val EmitStructFieldAccess(BoundStructFieldAccess structFieldAccess)
|
||||
{
|
||||
var target = EmitUnwrap(EmitExpression(structFieldAccess.Target));
|
||||
|
||||
var structDef = _definitionTable.LookupStruct(structFieldAccess.StructType.Namespace, structFieldAccess.StructType.Name);
|
||||
var offset = OffsetOf(structDef, structFieldAccess.Field);
|
||||
|
||||
var output = TmpName();
|
||||
_writer.Indented($"{output} =l add {target}, {offset}");
|
||||
|
||||
// If the accessed member is an inline struct, it will not be a pointer
|
||||
if (structFieldAccess.Type is NubCustomType customType && customType.Kind(_definitionTable) == CustomTypeKind.Struct)
|
||||
{
|
||||
return new Val(output, structFieldAccess.Type, ValKind.Direct);
|
||||
}
|
||||
|
||||
return new Val(output, structFieldAccess.Type, ValKind.Pointer);
|
||||
}
|
||||
|
||||
private Val EmitTraitFuncAccess(BoundTraitFuncAccess traitFuncAccess)
|
||||
{
|
||||
throw new NotImplementedException();
|
||||
}
|
||||
|
||||
private Val EmitTraitImplFuncAccess(BoundTraitImplFuncAccess traitImplFuncAccess)
|
||||
{
|
||||
var target = EmitExpression(traitImplFuncAccess.Target);
|
||||
|
||||
var funcImpl = _definitionTable.LookupTraitFuncImpl(traitImplFuncAccess.Target.Type, traitImplFuncAccess.FuncName);
|
||||
|
||||
var name = ImplFuncName();
|
||||
_implFunctions.TryAdd(funcImpl, name);
|
||||
return new Val(name, traitImplFuncAccess.Type, ValKind.Direct, new MethodCallContext(target));
|
||||
}
|
||||
|
||||
private Val EmitFuncCall(BoundFuncCall funcCall)
|
||||
{
|
||||
var expression = EmitExpression(funcCall.Expression);
|
||||
var funcPointer = EmitUnwrap(expression);
|
||||
|
||||
var parameterStrings = new List<string>();
|
||||
|
||||
if (expression.FuncCallContext != null)
|
||||
{
|
||||
var thisArg = EmitUnwrap(expression.FuncCallContext.ThisArg);
|
||||
parameterStrings.Add($"{FuncQBETypeName(expression.FuncCallContext.ThisArg.Type)} {thisArg}");
|
||||
}
|
||||
|
||||
foreach (var parameter in funcCall.Parameters)
|
||||
{
|
||||
var copy = EmitCreateCopyOrInitialize(parameter);
|
||||
parameterStrings.Add($"{FuncQBETypeName(parameter.Type)} {copy}");
|
||||
}
|
||||
|
||||
if (funcCall.Type is NubVoidType)
|
||||
{
|
||||
_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);
|
||||
}
|
||||
}
|
||||
}
|
||||
Reference in New Issue
Block a user