nub31/nub-lang-archive-2
Archived
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

...

Browse Source
This commit is contained in:
nub31
2025-06-21 17:34:34 +02:00
parent 99802c1abb
commit a97aed0b9c
2 changed files with 208 additions and 201 deletions
Download Patch File Download Diff File Expand all files Collapse all files

407
src/Generation/QBE/QBEGenerator.cs
View File

@@ -71,9 +71,9 @@ public static class QBEGenerator
return _builder.ToString(); return _builder.ToString();
} }
private static Tmp NewTmp() private static string VarName()
{ {
return new Tmp($"%v{++_variableIndex}"); return $"%v{++_variableIndex}";
} }
private static string LabelName() private static string LabelName()
@@ -389,32 +389,32 @@ public static class QBEGenerator
foreach (var parameter in parameters) foreach (var parameter in parameters)
{ {
var parameterName = new Tmp("%" + parameter.Name); var parameterName = "%" + parameter.Name;
if (parameter.Type is NubPrimitiveType primitiveType) if (parameter.Type is NubPrimitiveType primitiveType)
{ {
switch (primitiveType.Kind) switch (primitiveType.Kind)
{ {
case PrimitiveTypeKind.I16: case PrimitiveTypeKind.I16:
parameterName = NewTmp(); parameterName = VarName();
_builder.AppendLine($" {parameterName} =w extsh %{parameter.Name}"); _builder.AppendLine($" {parameterName} =w extsh %{parameter.Name}");
break; break;
case PrimitiveTypeKind.I8: case PrimitiveTypeKind.I8:
parameterName = NewTmp(); parameterName = VarName();
_builder.AppendLine($" {parameterName} =w extsb %{parameter.Name}"); _builder.AppendLine($" {parameterName} =w extsb %{parameter.Name}");
break; break;
case PrimitiveTypeKind.U16: case PrimitiveTypeKind.U16:
parameterName = NewTmp(); parameterName = VarName();
_builder.AppendLine($" {parameterName} =w extuh %{parameter.Name}"); _builder.AppendLine($" {parameterName} =w extuh %{parameter.Name}");
break; break;
case PrimitiveTypeKind.U8: case PrimitiveTypeKind.U8:
parameterName = NewTmp(); parameterName = VarName();
_builder.AppendLine($" {parameterName} =w extub %{parameter.Name}"); _builder.AppendLine($" {parameterName} =w extub %{parameter.Name}");
break; break;
} }
} }
parameterVars.Add(new Variable(parameter.Name, parameterName).Assign()); parameterVars.Add(new Variable(parameter.Name, new Ident(parameterName, parameter.Type)).Assign());
} }
GenerateBlock(body, parameterVars); GenerateBlock(body, parameterVars);
@@ -510,37 +510,29 @@ public static class QBEGenerator
private static void GenerateArrayIndexAssignment(ArrayIndexAssignmentNode arrayIndexAssignment) private static void GenerateArrayIndexAssignment(ArrayIndexAssignmentNode arrayIndexAssignment)
{ {
var array = GenerateExpression(arrayIndexAssignment.ArrayIndexAccess.Array); var array = Unwrap(GenerateExpression(arrayIndexAssignment.ArrayIndexAccess.Array));
var index = GenerateExpression(arrayIndexAssignment.ArrayIndexAccess.Index); var index = Unwrap(GenerateExpression(arrayIndexAssignment.ArrayIndexAccess.Index));
GenerateArrayBoundsCheck(array, index); GenerateArrayBoundsCheck(array, index);
var value = GenerateExpression(arrayIndexAssignment.Value); var value = Unwrap(GenerateExpression(arrayIndexAssignment.Value));
switch (arrayIndexAssignment.ArrayIndexAccess.Array.Type) switch (arrayIndexAssignment.ArrayIndexAccess.Array.Type)
{ {
case NubArrayType arrayType: case NubArrayType arrayType:
{ {
var startName = NewTmp(); var pointer = VarName();
_builder.AppendLine($" {startName} =l add {array}, 8"); _builder.AppendLine($" {pointer} =l mul {index}, {SizeOf(arrayType.ElementType)}");
_builder.AppendLine($" {pointer} =l add {pointer}, 8");
var adjustedIndex = NewTmp(); _builder.AppendLine($" {pointer} =l add {array}, {pointer}");
_builder.AppendLine($" {adjustedIndex} =l mul {index}, {SizeOf(arrayType.ElementType)}");
var pointer = NewTmp();
_builder.AppendLine($" {pointer} =l add {startName}, {adjustedIndex}");
GenerateCopy(arrayType.ElementType, value, pointer); GenerateCopy(arrayType.ElementType, value, pointer);
break; break;
} }
case NubFixedArrayType fixedArrayType: case NubFixedArrayType fixedArrayType:
{ {
var startName = NewTmp(); var pointer = VarName();
_builder.AppendLine($" {startName} =l add {array}, 8"); _builder.AppendLine($" {pointer} =l mul {index}, {SizeOf(fixedArrayType.ElementType)}");
_builder.AppendLine($" {pointer} =l add {pointer}, 8");
var adjustedIndex = NewTmp(); _builder.AppendLine($" {pointer} =l add {array}, {pointer}");
_builder.AppendLine($" {adjustedIndex} =l mul {index}, {SizeOf(fixedArrayType.ElementType)}");
var pointer = NewTmp();
_builder.AppendLine($" {pointer} =l add {startName}, {adjustedIndex}");
GenerateCopy(fixedArrayType.ElementType, value, pointer); GenerateCopy(fixedArrayType.ElementType, value, pointer);
break; break;
@@ -591,8 +583,8 @@ public static class QBEGenerator
private static void GenerateDereferenceAssignment(DereferenceAssignmentNode dereferenceAssignment) private static void GenerateDereferenceAssignment(DereferenceAssignmentNode dereferenceAssignment)
{ {
var pointer = GenerateExpression(dereferenceAssignment.Dereference.Expression); var pointer = Unwrap(GenerateExpression(dereferenceAssignment.Dereference.Expression));
var value = GenerateExpression(dereferenceAssignment.Value); var value = Unwrap(GenerateExpression(dereferenceAssignment.Value));
GenerateCopy(dereferenceAssignment.Value.Type, value, pointer); GenerateCopy(dereferenceAssignment.Value.Type, value, pointer);
} }
@@ -602,7 +594,7 @@ public static class QBEGenerator
var falseLabel = LabelName(); var falseLabel = LabelName();
var endLabel = LabelName(); var endLabel = LabelName();
var result = GenerateExpression(ifStatement.Condition); var result = Unwrap(GenerateExpression(ifStatement.Condition));
_builder.AppendLine($" jnz {result}, {trueLabel}, {falseLabel}"); _builder.AppendLine($" jnz {result}, {trueLabel}, {falseLabel}");
_builder.AppendLine(trueLabel); _builder.AppendLine(trueLabel);
GenerateBlock(ifStatement.Body); GenerateBlock(ifStatement.Body);
@@ -628,12 +620,12 @@ public static class QBEGenerator
var structDefinition = _definitionTable.LookupStruct(structType.Namespace, structType.Name).GetValue(); var structDefinition = _definitionTable.LookupStruct(structType.Namespace, structType.Name).GetValue();
var offset = OffsetOf(structDefinition, memberAssignment.MemberAccess.Member); var offset = OffsetOf(structDefinition, memberAssignment.MemberAccess.Member);
var item = GenerateExpression(memberAssignment.MemberAccess.Expression); var item = Unwrap(GenerateExpression(memberAssignment.MemberAccess.Expression));
var pointer = NewTmp(); var pointer = VarName();
_builder.AppendLine($" {pointer} =l add {item}, {offset}"); _builder.AppendLine($" {pointer} =l add {item}, {offset}");
var value = GenerateExpression(memberAssignment.Value); var value = Unwrap(GenerateExpression(memberAssignment.Value));
GenerateCopy(memberAssignment.Value.Type, value, pointer); GenerateCopy(memberAssignment.Value.Type, value, pointer);
} }
@@ -642,7 +634,7 @@ public static class QBEGenerator
{ {
if (@return.Value.HasValue) if (@return.Value.HasValue)
{ {
var result = GenerateExpression(@return.Value.Value); var result = Unwrap(GenerateExpression(@return.Value.Value));
_builder.AppendLine($" ret {result}"); _builder.AppendLine($" ret {result}");
} }
else else
@@ -653,16 +645,16 @@ public static class QBEGenerator
private static void GenerateVariableDeclaration(VariableDeclarationNode variableDeclaration) private static void GenerateVariableDeclaration(VariableDeclarationNode variableDeclaration)
{ {
var generatedName = NewTmp(); var tmp = VarName();
_builder.AppendLine($" {generatedName} =l alloc8 {SizeOf(variableDeclaration.Type)}"); _builder.AppendLine($" {tmp} =l alloc8 {SizeOf(variableDeclaration.Type)}");
_variables.Push(new Variable(variableDeclaration.Name, generatedName)); _variables.Push(new Variable(variableDeclaration.Name, new Ident(tmp, variableDeclaration.Type)));
} }
private static void GenerateVariableAssignment(VariableAssignmentNode variableAssignment) private static void GenerateVariableAssignment(VariableAssignmentNode variableAssignment)
{ {
var value = GenerateExpression(variableAssignment.Value); var value = Unwrap(GenerateExpression(variableAssignment.Value));
var variable = _variables.Single(x => x.Name == variableAssignment.Identifier.Name); var variable = _variables.Single(x => x.Name == variableAssignment.Identifier.Name);
GenerateCopy(variableAssignment.Value.Type, value, variable.Tmp); GenerateCopy(variableAssignment.Value.Type, value, variable.Ident.Name);
variable.Assign(); variable.Assign();
} }
@@ -679,7 +671,7 @@ public static class QBEGenerator
_builder.AppendLine(iterationLabel); _builder.AppendLine(iterationLabel);
GenerateBlock(whileStatement.Body); GenerateBlock(whileStatement.Body);
_builder.AppendLine(conditionLabel); _builder.AppendLine(conditionLabel);
var result = GenerateExpression(whileStatement.Condition); var result = Unwrap(GenerateExpression(whileStatement.Condition));
_builder.AppendLine($" jnz {result}, {iterationLabel}, {endLabel}"); _builder.AppendLine($" jnz {result}, {iterationLabel}, {endLabel}");
_builder.AppendLine(endLabel); _builder.AppendLine(endLabel);
@@ -687,7 +679,7 @@ public static class QBEGenerator
_breakLabels.Pop(); _breakLabels.Pop();
} }
private static Tmp GenerateExpression(ExpressionNode expression) private static Ident GenerateExpression(ExpressionNode expression)
{ {
return expression switch return expression switch
{ {
@@ -708,19 +700,17 @@ public static class QBEGenerator
}; };
} }
private static Tmp GenerateAnonymousFunc(AnonymousFuncNode anonymousFunc) private static Ident GenerateAnonymousFunc(AnonymousFuncNode anonymousFunc)
{ {
var name = $"$anon_func{++_anonymousFuncIndex}"; var name = $"$anon_func{++_anonymousFuncIndex}";
_anonymousFunctions.Enqueue((anonymousFunc, name)); _anonymousFunctions.Enqueue((anonymousFunc, name));
var tmp = NewTmp(); return new Ident(name, anonymousFunc.Type, IdentKind.Func);
_builder.AppendLine($" {NewTmp()} =l {name}");
return tmp;
} }
private static Tmp GenerateArrayIndexPointer(ArrayIndexAccessNode arrayIndexAccess) private static string GenerateArrayIndexPointer(ArrayIndexAccessNode arrayIndexAccess)
{ {
var array = GenerateExpression(arrayIndexAccess.Array); var array = Unwrap(GenerateExpression(arrayIndexAccess.Array));
var index = GenerateExpression(arrayIndexAccess.Index); var index = Unwrap(GenerateExpression(arrayIndexAccess.Index));
GenerateArrayBoundsCheck(array, index); GenerateArrayBoundsCheck(array, index);
var elementType = arrayIndexAccess.Array.Type switch var elementType = arrayIndexAccess.Array.Type switch
@@ -730,55 +720,38 @@ public static class QBEGenerator
_ => throw new ArgumentOutOfRangeException() _ => throw new ArgumentOutOfRangeException()
}; };
var firstItemPointerName = NewTmp(); var pointer = VarName();
_builder.AppendLine($" {firstItemPointerName} =l add {array}, 8"); _builder.AppendLine($" {pointer} =l mul {index}, {SizeOf(elementType)}");
var offsetPointerName = NewTmp(); _builder.AppendLine($" {pointer} =l add {pointer}, 8");
_builder.AppendLine($" {offsetPointerName} =l mul {index}, {SizeOf(elementType)}"); _builder.AppendLine($" {pointer} =l add {array}, {pointer}");
var resultPointerName = NewTmp(); return pointer;
_builder.AppendLine($" {resultPointerName} =l add {firstItemPointerName}, {offsetPointerName}");
return resultPointerName;
} }
private static Tmp GenerateArrayIndexAccess(ArrayIndexAccessNode arrayIndexAccess) private static Ident GenerateArrayIndexAccess(ArrayIndexAccessNode arrayIndexAccess)
{ {
var pointerName = GenerateArrayIndexPointer(arrayIndexAccess); var pointer = GenerateArrayIndexPointer(arrayIndexAccess);
var outputName = VarName();
var elementType = arrayIndexAccess.Array.Type switch _builder.AppendLine($" {outputName} {QBEAssign(arrayIndexAccess.Type)} {QBELoad(arrayIndexAccess.Type)} {pointer}");
{ return new Ident(outputName, arrayIndexAccess.Type);
NubArrayType arrayType => arrayType.ElementType,
NubFixedArrayType fixedArrayType => fixedArrayType.ElementType,
_ => throw new ArgumentOutOfRangeException()
};
if (SizeOf(elementType) > 8)
{
return pointerName;
}
else
{
var outputName = NewTmp();
_builder.AppendLine($" {outputName} {QBEAssign(arrayIndexAccess.Type)} {QBELoad(arrayIndexAccess.Type)} {pointerName}");
return outputName;
}
} }
private static void GenerateArrayBoundsCheck(Tmp array, Tmp index) private static void GenerateArrayBoundsCheck(string array, string index)
{ {
var countName = NewTmp(); var count = VarName();
_builder.AppendLine($" {countName} =l loadl {array}"); _builder.AppendLine($" {count} =l loadl {array}");
var isNegativeName = NewTmp(); var isNegative = VarName();
_builder.AppendLine($" {isNegativeName} =w csltl {index}, 0"); _builder.AppendLine($" {isNegative} =w csltl {index}, 0");
var isOobName = NewTmp(); var isOob = VarName();
_builder.AppendLine($" {isOobName} =w csgel {index}, {countName}"); _builder.AppendLine($" {isOob} =w csgel {index}, {count}");
var anyOobName = NewTmp(); var anyOob = VarName();
_builder.AppendLine($" {anyOobName} =w or {isNegativeName}, {isOobName}"); _builder.AppendLine($" {anyOob} =w or {isNegative}, {isOob}");
var oobLabel = LabelName(); var oobLabel = LabelName();
var notOobLabel = LabelName(); var notOobLabel = LabelName();
_builder.AppendLine($" jnz {anyOobName}, {oobLabel}, {notOobLabel}"); _builder.AppendLine($" jnz {anyOob}, {oobLabel}, {notOobLabel}");
_builder.AppendLine(oobLabel); _builder.AppendLine(oobLabel);
_builder.AppendLine($" call $nub_panic_array_oob()"); _builder.AppendLine($" call $nub_panic_array_oob()");
@@ -786,39 +759,42 @@ public static class QBEGenerator
_builder.AppendLine(notOobLabel); _builder.AppendLine(notOobLabel);
} }
private static Tmp GenerateArrayInitializer(ArrayInitializerNode arrayInitializer) private static Ident GenerateArrayInitializer(ArrayInitializerNode arrayInitializer)
{ {
var capacity = GenerateExpression(arrayInitializer.Capacity); var capacity = Unwrap(GenerateExpression(arrayInitializer.Capacity));
var elementSize = SizeOf(arrayInitializer.ElementType); var elementSize = SizeOf(arrayInitializer.ElementType);
var capacityInBytes = NewTmp();
var capacityInBytes = VarName();
_builder.AppendLine($" {capacityInBytes} =l mul {capacity}, {elementSize}"); _builder.AppendLine($" {capacityInBytes} =l mul {capacity}, {elementSize}");
var totalArraySize = NewTmp(); var totalSize = VarName();
_builder.AppendLine($" {totalArraySize} =l add {capacityInBytes}, 8"); _builder.AppendLine($" {totalSize} =l add {capacityInBytes}, 8");
var outputName = NewTmp();
_builder.AppendLine($" {outputName} =l alloc8 {totalArraySize}");
_builder.AppendLine($" storel {capacity}, {outputName}");
var dataPtr = NewTmp(); var arrayPointer = VarName();
_builder.AppendLine($" {dataPtr} =l add {outputName}, 8"); _builder.AppendLine($" {arrayPointer} =l alloc8 {totalSize}");
_builder.AppendLine($" call $nub_memset(l {dataPtr}, w 0, l {capacityInBytes})"); _builder.AppendLine($" storel {capacity}, {arrayPointer}");
return outputName; var dataPointer = VarName();
_builder.AppendLine($" {dataPointer} =l add {arrayPointer}, 8");
_builder.AppendLine($" call $nub_memset(l {dataPointer}, w 0, l {capacityInBytes})");
return new Ident(arrayPointer, arrayInitializer.Type);
} }
private static Tmp GenerateDereference(DereferenceNode dereference) private static Ident GenerateDereference(DereferenceNode dereference)
{ {
var result = GenerateExpression(dereference.Expression); var result = Unwrap(GenerateExpression(dereference.Expression));
var outputName = NewTmp(); var outputName = VarName();
_builder.AppendLine($" {outputName} {QBEAssign(dereference.Type)} {QBELoad(dereference.Type)} {result}"); _builder.AppendLine($" {outputName} {QBEAssign(dereference.Type)} {QBELoad(dereference.Type)} {result}");
return outputName; return new Ident(outputName, dereference.Type);
} }
private static Tmp GenerateAddressOf(AddressOfNode addressOf) private static Ident GenerateAddressOf(AddressOfNode addressOf)
{ {
switch (addressOf.Expression) switch (addressOf.Expression)
{ {
case ArrayIndexAccessNode arrayIndexAccess: case ArrayIndexAccessNode arrayIndexAccess:
return GenerateArrayIndexPointer(arrayIndexAccess); var pointer = GenerateArrayIndexPointer(arrayIndexAccess);
return new Ident(pointer, addressOf.Type);
case DereferenceNode dereference: case DereferenceNode dereference:
return GenerateExpression(dereference.Expression); return GenerateExpression(dereference.Expression);
case IdentifierNode identifier: case IdentifierNode identifier:
@@ -827,19 +803,21 @@ public static class QBEGenerator
throw new NotSupportedException("There is nothing to address in another namespace"); throw new NotSupportedException("There is nothing to address in another namespace");
} }
return _variables.Single(x => x.Name == identifier.Name).Tmp; return _variables.Single(x => x.Name == identifier.Name).Ident;
case MemberAccessNode memberAccess: case MemberAccessNode memberAccess:
return GenerateMemberAccessPointer(memberAccess); var ptr = GenerateMemberAccessPointer(memberAccess);
return new Ident(ptr, addressOf.Type);
default: default:
throw new ArgumentOutOfRangeException(); throw new ArgumentOutOfRangeException();
} }
} }
private static Tmp GenerateBinaryExpression(BinaryExpressionNode binaryExpression) private static Ident GenerateBinaryExpression(BinaryExpressionNode binaryExpression)
{ {
var left = GenerateExpression(binaryExpression.Left); var left = Unwrap(GenerateExpression(binaryExpression.Left));
var right = GenerateExpression(binaryExpression.Right); var right = Unwrap(GenerateExpression(binaryExpression.Right));
var outputName = NewTmp(); var outputName = VarName();
var output = new Ident(outputName, binaryExpression.Type);
switch (binaryExpression.Operator) switch (binaryExpression.Operator)
{ {
@@ -848,19 +826,19 @@ public static class QBEGenerator
if (binaryExpression.Left.Type.Equals(NubPrimitiveType.I64)) if (binaryExpression.Left.Type.Equals(NubPrimitiveType.I64))
{ {
_builder.AppendLine($" {outputName} =w ceql {left}, {right}"); _builder.AppendLine($" {outputName} =w ceql {left}, {right}");
return outputName; return output;
} }
if (binaryExpression.Left.Type.Equals(NubPrimitiveType.I32)) if (binaryExpression.Left.Type.Equals(NubPrimitiveType.I32))
{ {
_builder.AppendLine($" {outputName} =w ceqw {left}, {right}"); _builder.AppendLine($" {outputName} =w ceqw {left}, {right}");
return outputName; return output;
} }
if (binaryExpression.Left.Type.Equals(NubPrimitiveType.Bool)) if (binaryExpression.Left.Type.Equals(NubPrimitiveType.Bool))
{ {
_builder.AppendLine($" {outputName} =w ceqw {left}, {right}"); _builder.AppendLine($" {outputName} =w ceqw {left}, {right}");
return outputName; return output;
} }
break; break;
@@ -870,19 +848,19 @@ public static class QBEGenerator
if (binaryExpression.Left.Type.Equals(NubPrimitiveType.I64)) if (binaryExpression.Left.Type.Equals(NubPrimitiveType.I64))
{ {
_builder.AppendLine($" {outputName} =w cnel {left}, {right}"); _builder.AppendLine($" {outputName} =w cnel {left}, {right}");
return outputName; return output;
} }
if (binaryExpression.Left.Type.Equals(NubPrimitiveType.I32)) if (binaryExpression.Left.Type.Equals(NubPrimitiveType.I32))
{ {
_builder.AppendLine($" {outputName} =w cnew {left}, {right}"); _builder.AppendLine($" {outputName} =w cnew {left}, {right}");
return outputName; return output;
} }
if (binaryExpression.Left.Type.Equals(NubPrimitiveType.Bool)) if (binaryExpression.Left.Type.Equals(NubPrimitiveType.Bool))
{ {
_builder.AppendLine($" {outputName} =w cnew {left}, {right}"); _builder.AppendLine($" {outputName} =w cnew {left}, {right}");
return outputName; return output;
} }
break; break;
@@ -892,19 +870,19 @@ public static class QBEGenerator
if (binaryExpression.Left.Type.Equals(NubPrimitiveType.I64)) if (binaryExpression.Left.Type.Equals(NubPrimitiveType.I64))
{ {
_builder.AppendLine($" {outputName} =w csgtl {left}, {right}"); _builder.AppendLine($" {outputName} =w csgtl {left}, {right}");
return outputName; return output;
} }
if (binaryExpression.Left.Type.Equals(NubPrimitiveType.I32)) if (binaryExpression.Left.Type.Equals(NubPrimitiveType.I32))
{ {
_builder.AppendLine($" {outputName} =w csgtw {left}, {right}"); _builder.AppendLine($" {outputName} =w csgtw {left}, {right}");
return outputName; return output;
} }
if (binaryExpression.Left.Type.Equals(NubPrimitiveType.Bool)) if (binaryExpression.Left.Type.Equals(NubPrimitiveType.Bool))
{ {
_builder.AppendLine($" {outputName} =w csgtw {left}, {right}"); _builder.AppendLine($" {outputName} =w csgtw {left}, {right}");
return outputName; return output;
} }
break; break;
@@ -914,19 +892,19 @@ public static class QBEGenerator
if (binaryExpression.Left.Type.Equals(NubPrimitiveType.I64)) if (binaryExpression.Left.Type.Equals(NubPrimitiveType.I64))
{ {
_builder.AppendLine($" {outputName} =w csgel {left}, {right}"); _builder.AppendLine($" {outputName} =w csgel {left}, {right}");
return outputName; return output;
} }
if (binaryExpression.Left.Type.Equals(NubPrimitiveType.I32)) if (binaryExpression.Left.Type.Equals(NubPrimitiveType.I32))
{ {
_builder.AppendLine($" {outputName} =w csgew {left}, {right}"); _builder.AppendLine($" {outputName} =w csgew {left}, {right}");
return outputName; return output;
} }
if (binaryExpression.Left.Type.Equals(NubPrimitiveType.Bool)) if (binaryExpression.Left.Type.Equals(NubPrimitiveType.Bool))
{ {
_builder.AppendLine($" {outputName} =w csgew {left}, {right}"); _builder.AppendLine($" {outputName} =w csgew {left}, {right}");
return outputName; return output;
} }
break; break;
@@ -936,19 +914,19 @@ public static class QBEGenerator
if (binaryExpression.Left.Type.Equals(NubPrimitiveType.I64)) if (binaryExpression.Left.Type.Equals(NubPrimitiveType.I64))
{ {
_builder.AppendLine($" {outputName} =w csltl {left}, {right}"); _builder.AppendLine($" {outputName} =w csltl {left}, {right}");
return outputName; return output;
} }
if (binaryExpression.Left.Type.Equals(NubPrimitiveType.I32)) if (binaryExpression.Left.Type.Equals(NubPrimitiveType.I32))
{ {
_builder.AppendLine($" {outputName} =w csltw {left}, {right}"); _builder.AppendLine($" {outputName} =w csltw {left}, {right}");
return outputName; return output;
} }
if (binaryExpression.Left.Type.Equals(NubPrimitiveType.Bool)) if (binaryExpression.Left.Type.Equals(NubPrimitiveType.Bool))
{ {
_builder.AppendLine($" {outputName} =w csltw {left}, {right}"); _builder.AppendLine($" {outputName} =w csltw {left}, {right}");
return outputName; return output;
} }
break; break;
@@ -958,19 +936,19 @@ public static class QBEGenerator
if (binaryExpression.Left.Type.Equals(NubPrimitiveType.I64)) if (binaryExpression.Left.Type.Equals(NubPrimitiveType.I64))
{ {
_builder.AppendLine($" {outputName} =w cslel {left}, {right}"); _builder.AppendLine($" {outputName} =w cslel {left}, {right}");
return outputName; return output;
} }
if (binaryExpression.Left.Type.Equals(NubPrimitiveType.I32)) if (binaryExpression.Left.Type.Equals(NubPrimitiveType.I32))
{ {
_builder.AppendLine($" {outputName} =w cslew {left}, {right}"); _builder.AppendLine($" {outputName} =w cslew {left}, {right}");
return outputName; return output;
} }
if (binaryExpression.Left.Type.Equals(NubPrimitiveType.Bool)) if (binaryExpression.Left.Type.Equals(NubPrimitiveType.Bool))
{ {
_builder.AppendLine($" {outputName} =w cslew {left}, {right}"); _builder.AppendLine($" {outputName} =w cslew {left}, {right}");
return outputName; return output;
} }
break; break;
@@ -980,13 +958,13 @@ public static class QBEGenerator
if (binaryExpression.Left.Type.Equals(NubPrimitiveType.I64)) if (binaryExpression.Left.Type.Equals(NubPrimitiveType.I64))
{ {
_builder.AppendLine($" {outputName} =l add {left}, {right}"); _builder.AppendLine($" {outputName} =l add {left}, {right}");
return outputName; return output;
} }
if (binaryExpression.Left.Type.Equals(NubPrimitiveType.I32)) if (binaryExpression.Left.Type.Equals(NubPrimitiveType.I32))
{ {
_builder.AppendLine($" {outputName} =w add {left}, {right}"); _builder.AppendLine($" {outputName} =w add {left}, {right}");
return outputName; return output;
} }
break; break;
@@ -996,13 +974,13 @@ public static class QBEGenerator
if (binaryExpression.Left.Type.Equals(NubPrimitiveType.I64)) if (binaryExpression.Left.Type.Equals(NubPrimitiveType.I64))
{ {
_builder.AppendLine($" {outputName} =l sub {left}, {right}"); _builder.AppendLine($" {outputName} =l sub {left}, {right}");
return outputName; return output;
} }
if (binaryExpression.Left.Type.Equals(NubPrimitiveType.I32)) if (binaryExpression.Left.Type.Equals(NubPrimitiveType.I32))
{ {
_builder.AppendLine($" {outputName} =w sub {left}, {right}"); _builder.AppendLine($" {outputName} =w sub {left}, {right}");
return outputName; return output;
} }
break; break;
@@ -1012,13 +990,13 @@ public static class QBEGenerator
if (binaryExpression.Left.Type.Equals(NubPrimitiveType.I64)) if (binaryExpression.Left.Type.Equals(NubPrimitiveType.I64))
{ {
_builder.AppendLine($" {outputName} =l mul {left}, {right}"); _builder.AppendLine($" {outputName} =l mul {left}, {right}");
return outputName; return output;
} }
if (binaryExpression.Left.Type.Equals(NubPrimitiveType.I32)) if (binaryExpression.Left.Type.Equals(NubPrimitiveType.I32))
{ {
_builder.AppendLine($" {outputName} =w mul {left}, {right}"); _builder.AppendLine($" {outputName} =w mul {left}, {right}");
return outputName; return output;
} }
break; break;
@@ -1028,13 +1006,13 @@ public static class QBEGenerator
if (binaryExpression.Left.Type.Equals(NubPrimitiveType.I64)) if (binaryExpression.Left.Type.Equals(NubPrimitiveType.I64))
{ {
_builder.AppendLine($" {outputName} =l div {left}, {right}"); _builder.AppendLine($" {outputName} =l div {left}, {right}");
return outputName; return output;
} }
if (binaryExpression.Left.Type.Equals(NubPrimitiveType.I32)) if (binaryExpression.Left.Type.Equals(NubPrimitiveType.I32))
{ {
_builder.AppendLine($" {outputName} =w div {left}, {right}"); _builder.AppendLine($" {outputName} =w div {left}, {right}");
return outputName; return output;
} }
break; break;
@@ -1048,11 +1026,11 @@ public static class QBEGenerator
throw new NotSupportedException($"Binary operator {binaryExpression.Operator} for types {binaryExpression.Left.Type} and {binaryExpression.Right.Type} not supported"); throw new NotSupportedException($"Binary operator {binaryExpression.Operator} for types {binaryExpression.Left.Type} and {binaryExpression.Right.Type} not supported");
} }
private static Tmp GenerateIdentifier(IdentifierNode identifier) private static Ident GenerateIdentifier(IdentifierNode identifier)
{ {
if (_definitionTable.LookupFunc(identifier.Namespace.Or(_compilationUnit.Namespace), identifier.Name).TryGetValue(out var func)) if (_definitionTable.LookupFunc(identifier.Namespace.Or(_compilationUnit.Namespace), identifier.Name).TryGetValue(out var func))
{ {
return new Tmp(FuncName(func)); return new Ident(FuncName(func), identifier.Type, IdentKind.Func);
} }
if (!identifier.Namespace.HasValue) if (!identifier.Namespace.HasValue)
@@ -1060,29 +1038,29 @@ public static class QBEGenerator
var variable = _variables.Single(v => v.Name == identifier.Name); var variable = _variables.Single(v => v.Name == identifier.Name);
if (IsPointerType(identifier.Type)) if (IsPointerType(identifier.Type))
{ {
return variable.Tmp; return variable.Ident;
} }
else else
{ {
var output = NewTmp(); var output = VarName();
_builder.AppendLine($" {output} {QBEAssign(identifier.Type)} {QBELoad(identifier.Type)} {variable.Tmp}"); _builder.AppendLine($" {output} {QBEAssign(identifier.Type)} {QBELoad(identifier.Type)} {variable.Ident}");
return output; return new Ident(output, identifier.Type);
} }
} }
throw new UnreachableException(); throw new UnreachableException();
} }
private static Tmp GenerateLiteral(LiteralNode literal) private static Ident GenerateLiteral(LiteralNode literal)
{ {
if (literal.Type.IsInteger) if (literal.Type.IsInteger)
{ {
switch (literal.Kind) switch (literal.Kind)
{ {
case LiteralKind.Integer: case LiteralKind.Integer:
return new Tmp(literal.Literal); return new Ident(literal.Literal, literal.Type, IdentKind.Literal);
case LiteralKind.Float: case LiteralKind.Float:
return new Tmp(literal.Literal.Split(".").First()); return new Ident(literal.Literal.Split(".").First(), literal.Type, IdentKind.Literal);
default: default:
throw new ArgumentOutOfRangeException(); throw new ArgumentOutOfRangeException();
} }
@@ -1092,35 +1070,35 @@ public static class QBEGenerator
{ {
var value = double.Parse(literal.Literal, CultureInfo.InvariantCulture); var value = double.Parse(literal.Literal, CultureInfo.InvariantCulture);
var bits = BitConverter.DoubleToInt64Bits(value); var bits = BitConverter.DoubleToInt64Bits(value);
return new Tmp(bits.ToString()); return new Ident(bits.ToString(), literal.Type, IdentKind.Literal);
} }
if (literal.Type.IsFloat32) if (literal.Type.IsFloat32)
{ {
var value = float.Parse(literal.Literal, CultureInfo.InvariantCulture); var value = float.Parse(literal.Literal, CultureInfo.InvariantCulture);
var bits = BitConverter.SingleToInt32Bits(value); var bits = BitConverter.SingleToInt32Bits(value);
return new Tmp(bits.ToString()); return new Ident(bits.ToString(), literal.Type, IdentKind.Literal);
} }
switch (literal.Kind) switch (literal.Kind)
{ {
case LiteralKind.String: case LiteralKind.String:
_strings.Add(literal.Literal); _strings.Add(literal.Literal);
return new Tmp($"$string{_strings.Count}"); return new Ident($"$string{_strings.Count}", literal.Type, IdentKind.Literal);
case LiteralKind.Bool: case LiteralKind.Bool:
return new Tmp(bool.Parse(literal.Literal) ? "1" : "0"); return new Ident(bool.Parse(literal.Literal) ? "1" : "0", literal.Type, IdentKind.Literal);
default: default:
throw new ArgumentOutOfRangeException(); throw new ArgumentOutOfRangeException();
} }
} }
private static Tmp GenerateStructInitializer(StructInitializerNode structInitializer) private static Ident GenerateStructInitializer(StructInitializerNode structInitializer)
{ {
var structDefinition = _definitionTable.LookupStruct(structInitializer.StructType.Namespace, structInitializer.StructType.Name).GetValue(); var structDefinition = _definitionTable.LookupStruct(structInitializer.StructType.Namespace, structInitializer.StructType.Name).GetValue();
var structVar = NewTmp(); var output = VarName();
var size = SizeOf(structInitializer.StructType); var size = SizeOf(structInitializer.StructType);
_builder.AppendLine($" {structVar} =l alloc8 {size}"); _builder.AppendLine($" {output} =l alloc8 {size}");
foreach (var field in structDefinition.Fields) foreach (var field in structDefinition.Fields)
{ {
@@ -1128,16 +1106,16 @@ public static class QBEGenerator
if (structInitializer.Initializers.TryGetValue(field.Name, out var fieldValue)) if (structInitializer.Initializers.TryGetValue(field.Name, out var fieldValue))
{ {
var value = GenerateExpression(fieldValue); var value = Unwrap(GenerateExpression(fieldValue));
var pointer = NewTmp(); var pointer = VarName();
_builder.AppendLine($" {pointer} =l add {structVar}, {offset}"); _builder.AppendLine($" {pointer} =l add {output}, {offset}");
GenerateCopy(field.Type, value, pointer); GenerateCopy(field.Type, value, pointer);
} }
else if (field.Value.HasValue) else if (field.Value.HasValue)
{ {
var value = GenerateExpression(field.Value.Value); var value = Unwrap(GenerateExpression(field.Value.Value));
var pointer = NewTmp(); var pointer = VarName();
_builder.AppendLine($" {pointer} =l add {structVar}, {offset}"); _builder.AppendLine($" {pointer} =l add {output}, {offset}");
GenerateCopy(field.Type, value, pointer); GenerateCopy(field.Type, value, pointer);
} }
else else
@@ -1146,13 +1124,13 @@ public static class QBEGenerator
} }
} }
return structVar; return new Ident(output, structInitializer.StructType);
} }
private static Tmp GenerateUnaryExpression(UnaryExpressionNode unaryExpression) private static Ident GenerateUnaryExpression(UnaryExpressionNode unaryExpression)
{ {
var operand = GenerateExpression(unaryExpression.Operand); var operand = Unwrap(GenerateExpression(unaryExpression.Operand));
var outputName = NewTmp(); var outputName = VarName();
switch (unaryExpression.Operator) switch (unaryExpression.Operator)
{ {
@@ -1162,16 +1140,16 @@ public static class QBEGenerator
{ {
case NubPrimitiveType { Kind: PrimitiveTypeKind.I64 }: case NubPrimitiveType { Kind: PrimitiveTypeKind.I64 }:
_builder.AppendLine($" {outputName} =l neg {operand}"); _builder.AppendLine($" {outputName} =l neg {operand}");
return outputName; return new Ident(outputName, unaryExpression.Type);
case NubPrimitiveType { Kind: PrimitiveTypeKind.I32 or PrimitiveTypeKind.I16 or PrimitiveTypeKind.I8 }: case NubPrimitiveType { Kind: PrimitiveTypeKind.I32 or PrimitiveTypeKind.I16 or PrimitiveTypeKind.I8 }:
_builder.AppendLine($" {outputName} =w neg {operand}"); _builder.AppendLine($" {outputName} =w neg {operand}");
return outputName; return new Ident(outputName, unaryExpression.Type);
case NubPrimitiveType { Kind: PrimitiveTypeKind.F64 }: case NubPrimitiveType { Kind: PrimitiveTypeKind.F64 }:
_builder.AppendLine($" {outputName} =d neg {operand}"); _builder.AppendLine($" {outputName} =d neg {operand}");
return outputName; return new Ident(outputName, unaryExpression.Type);
case NubPrimitiveType { Kind: PrimitiveTypeKind.F32 }: case NubPrimitiveType { Kind: PrimitiveTypeKind.F32 }:
_builder.AppendLine($" {outputName} =s neg {operand}"); _builder.AppendLine($" {outputName} =s neg {operand}");
return outputName; return new Ident(outputName, unaryExpression.Type);
} }
break; break;
@@ -1182,7 +1160,7 @@ public static class QBEGenerator
{ {
case NubPrimitiveType { Kind: PrimitiveTypeKind.Bool }: case NubPrimitiveType { Kind: PrimitiveTypeKind.Bool }:
_builder.AppendLine($" {outputName} =w xor {operand}, 1"); _builder.AppendLine($" {outputName} =w xor {operand}, 1");
return outputName; return new Ident(outputName, unaryExpression.Type);
} }
break; break;
@@ -1196,9 +1174,9 @@ public static class QBEGenerator
throw new NotSupportedException($"Unary operator {unaryExpression.Operator} for type {unaryExpression.Operand.Type} not supported"); throw new NotSupportedException($"Unary operator {unaryExpression.Operator} for type {unaryExpression.Operand.Type} not supported");
} }
private static Tmp GenerateMemberAccessPointer(MemberAccessNode memberAccess) private static string GenerateMemberAccessPointer(MemberAccessNode memberAccess)
{ {
var item = GenerateExpression(memberAccess.Expression); var item = Unwrap(GenerateExpression(memberAccess.Expression));
switch (memberAccess.Expression.Type) switch (memberAccess.Expression.Type)
{ {
case NubArrayType: case NubArrayType:
@@ -1215,7 +1193,7 @@ public static class QBEGenerator
var structDefinition = _definitionTable.LookupStruct(structType.Namespace, structType.Name).GetValue(); var structDefinition = _definitionTable.LookupStruct(structType.Namespace, structType.Name).GetValue();
var offset = OffsetOf(structDefinition, memberAccess.Member); var offset = OffsetOf(structDefinition, memberAccess.Member);
var offsetName = NewTmp(); var offsetName = VarName();
_builder.AppendLine($" {offsetName} =l add {item}, {offset}"); _builder.AppendLine($" {offsetName} =l add {item}, {offset}");
return offsetName; return offsetName;
} }
@@ -1226,40 +1204,33 @@ public static class QBEGenerator
} }
} }
private static Tmp GenerateMemberAccess(MemberAccessNode memberAccess) private static Ident GenerateMemberAccess(MemberAccessNode memberAccess)
{ {
var pointer = GenerateMemberAccessPointer(memberAccess); var pointer = GenerateMemberAccessPointer(memberAccess);
if (SizeOf(memberAccess.Type) > 8) var output = VarName();
{ _builder.AppendLine($" {output} {QBEAssign(memberAccess.Type)} {QBELoad(memberAccess.Type)} {pointer}");
return pointer; return new Ident(output, memberAccess.Type);
}
else
{
var outputName = NewTmp();
_builder.AppendLine($" {outputName} {QBEAssign(memberAccess.Type)} {QBELoad(memberAccess.Type)} {pointer}");
return outputName;
}
} }
private static Tmp GenerateFixedArrayInitializer(FixedArrayInitializerNode fixedArrayInitializer) private static Ident GenerateFixedArrayInitializer(FixedArrayInitializerNode fixedArrayInitializer)
{ {
var totalSize = SizeOf(fixedArrayInitializer.Type); var totalSize = SizeOf(fixedArrayInitializer.Type);
var outputName = NewTmp(); var outputName = VarName();
_builder.AppendLine($" {outputName} =l alloc8 {totalSize}"); _builder.AppendLine($" {outputName} =l alloc8 {totalSize}");
_builder.AppendLine($" storel {fixedArrayInitializer.Capacity}, {outputName}"); _builder.AppendLine($" storel {fixedArrayInitializer.Capacity}, {outputName}");
var dataPtr = NewTmp(); var dataPtr = VarName();
_builder.AppendLine($" {dataPtr} =l add {outputName}, 8"); _builder.AppendLine($" {dataPtr} =l add {outputName}, 8");
var dataSize = totalSize - 8; var dataSize = totalSize - 8;
_builder.AppendLine($" call $nub_memset(l {dataPtr}, w 0, l {dataSize})"); _builder.AppendLine($" call $nub_memset(l {dataPtr}, w 0, l {dataSize})");
return outputName; return new Ident(outputName, fixedArrayInitializer.Type);
} }
private static Tmp GenerateFuncCall(FuncCallNode funcCall) private static Ident GenerateFuncCall(FuncCallNode funcCall)
{ {
var funcType = (NubFuncType)funcCall.Expression.Type; var funcType = (NubFuncType)funcCall.Expression.Type;
@@ -1268,7 +1239,7 @@ public static class QBEGenerator
for (var i = 0; i < funcCall.Parameters.Count; i++) for (var i = 0; i < funcCall.Parameters.Count; i++)
{ {
var parameter = funcCall.Parameters[i]; var parameter = funcCall.Parameters[i];
var result = GenerateExpression(parameter); var result = Unwrap(GenerateExpression(parameter));
var qbeType = parameter.Type switch var qbeType = parameter.Type switch
{ {
@@ -1298,38 +1269,66 @@ public static class QBEGenerator
parameterStrings.Add($"{qbeType} {result}"); parameterStrings.Add($"{qbeType} {result}");
} }
var funcPointer = GenerateExpression(funcCall.Expression); var funcPointer = Unwrap(GenerateExpression(funcCall.Expression));
if (funcType.ReturnType is not NubVoidType) if (funcType.ReturnType is not NubVoidType)
{ {
var outputName = NewTmp(); var outputName = VarName();
_builder.AppendLine($" {outputName} {QBEAssign(funcCall.Type)} call {funcPointer}({string.Join(", ", parameterStrings)})"); _builder.AppendLine($" {outputName} {QBEAssign(funcCall.Type)} call {funcPointer}({string.Join(", ", parameterStrings)})");
return outputName; return new Ident(outputName, funcCall.Type);
} }
else else
{ {
_builder.AppendLine($" call {funcPointer}({string.Join(", ", parameterStrings)})"); _builder.AppendLine($" call {funcPointer}({string.Join(", ", parameterStrings)})");
return new Tmp("fuck"); return new Ident(string.Empty, funcCall.Type);
} }
} }
private static void GenerateCopy(NubType type, Tmp source, Tmp destination) private static void GenerateCopy(NubType type, string source, string destinationPtr)
{ {
if (SizeOf(type) > 8) if (SizeOf(type) > 8)
{ {
_builder.AppendLine($" blit {source}, {destination}, {SizeOf(type)}"); _builder.AppendLine($" blit {source}, {destinationPtr}, {SizeOf(type)}");
} }
else else
{ {
_builder.AppendLine($" {QBEStore(type)} {source}, {destination}"); _builder.AppendLine($" {QBEStore(type)} {source}, {destinationPtr}");
}
}
private static string Unwrap(Ident ident)
{
if (ident.Type.IsVoid)
{
throw new InvalidOperationException("Cannot unwrap temporary of void type");
}
switch (ident.Kind)
{
case IdentKind.Func:
case IdentKind.Literal:
return ident.Name;
case IdentKind.Variable:
if (SizeOf(ident.Type) > 8)
{
return ident.Name;
}
else
{
var result = VarName();
_builder.AppendLine($" {result} {QBEAssign(ident.Type)} {QBELoad(ident.Type)} {ident.Name}");
return result;
}
default:
throw new ArgumentOutOfRangeException();
} }
} }
} }
internal class Variable(string name, Tmp tmp) internal class Variable(string name, Ident ident)
{ {
public string Name { get; init; } = name; public string Name { get; } = name;
public Tmp Tmp { get; init; } = tmp; public Ident Ident { get; } = ident;
public bool Initialized { get; private set; } public bool Initialized { get; private set; }
public Variable Assign() public Variable Assign()
@@ -1339,10 +1338,16 @@ internal class Variable(string name, Tmp tmp)
} }
} }
internal record Tmp(string Name) internal class Ident(string name, NubType type, IdentKind kind = IdentKind.Variable)
{ {
public override string ToString() public string Name { get; } = name;
{ public NubType Type { get; } = type;
return Name; public IdentKind Kind { get; } = kind;
} }
internal enum IdentKind
{
Func,
Variable,
Literal
} }

2
src/Syntax/Typing/NubType.cs
View File

@@ -43,6 +43,8 @@ public abstract class NubType
public bool IsNumber => IsFloat32 || IsFloat64 || IsInteger; public bool IsNumber => IsFloat32 || IsFloat64 || IsInteger;
public bool IsVoid => this is NubVoidType;
public abstract override bool Equals(object? obj); public abstract override bool Equals(object? obj);
public abstract override int GetHashCode(); public abstract override int GetHashCode();
public abstract override string ToString(); public abstract override string ToString();