Split sizeof(Identifier) and sizeof(TypeName)

ForNeVeR · Oct 26, 2023 · 281942c · 281942c
1 parent 01d6c17
commit 281942c
Show file tree

Hide file tree

Showing 11 changed files with 200 additions and 59 deletions.
diff --git a/Cesium.Ast/Expressions.cs b/Cesium.Ast/Expressions.cs
@@ -28,7 +28,9 @@ public record UnaryOperatorExpression(string Operator, Expression Target) : Expr
 public record IndirectionExpression(Expression Target) : Expression;
 
 // 6.5.3.4 The sizeof and _Alignof operators
-public record SizeOfOperatorExpression(TypeName TypeName) : Expression;
+public record IdentifierSizeOfOperatorExpression(IdentifierExpression Identifier) : Expression;
+
+public record TypeNameSizeOfOperatorExpression(TypeName TypeName) : Expression;
 
 // 6.5.4 Cast expression
 public record CastExpression(TypeName TypeName, Expression Target) : Expression;

diff --git a/Cesium.CodeGen.Tests/CodeGenSizeofTests.cs b/Cesium.CodeGen.Tests/CodeGenSizeofTests.cs
@@ -20,20 +20,17 @@ int main() {
 }");
 
     [Fact]
-    public Task NamedTypeSizeof() => DoTest(@"
+    public Task IdentifierSizeof() => DoTest(@"
 int main() {
     int a = 1;
     return sizeof(a);
 }");
 
     [Fact]
-    public Task GlobalStructSizeof() => DoTest(@"
-typedef struct {
-    int x;
-    int y;
-} foo;
+    public Task GlobalIdentifierSizeof() => DoTest(@"
+int a = 1;
 int main() {
-    return sizeof(foo);
+    return sizeof(a);
 }");
 
     [Fact]
@@ -42,4 +39,24 @@ int main() {
     int x[] = { 1,2,3,4,5 };
     return sizeof(x);
 }");
+
+    [Fact]
+    public Task EnumSizeof() => DoTest(@"
+int main() {
+    enum foo {
+        bar
+    };
+    return sizeof(enum foo);
+}");
+
+    /// TODO[#453]: Struct can't be resolved
+    //    [Fact]
+    //    public Task GlobalStructSizeof() => DoTest(@"
+    //typedef struct {
+    //    int x;
+    //    int y;
+    //} foo;
+    //int main() {
+    //    return sizeof(foo);
+    //}");
 }
diff --git a/Cesium.CodeGen.Tests/verified/CodeGenSizeofTests.EnumSizeof.verified.txt b/Cesium.CodeGen.Tests/verified/CodeGenSizeofTests.EnumSizeof.verified.txt
@@ -0,0 +1,13 @@
+System.Int32 <Module>::main()
+  IL_0000: sizeof System.Int32
+  IL_0006: ret
+
+System.Int32 <Module>::<SyntheticEntrypoint>()
+  Locals:
+    System.Int32 V_0
+  IL_0000: call System.Int32 <Module>::main()
+  IL_0005: stloc.s V_0
+  IL_0007: ldloc.s V_0
+  IL_0009: call System.Void Cesium.Runtime.RuntimeHelpers::Exit(System.Int32)
+  IL_000e: ldloc.s V_0
+  IL_0010: ret
diff --git a/Cesium.CodeGen.Tests/verified/CodeGenSizeofTests.GlobalIdentifierSizeof.verified.txt b/Cesium.CodeGen.Tests/verified/CodeGenSizeofTests.GlobalIdentifierSizeof.verified.txt
@@ -0,0 +1,18 @@
+System.Void <Module>::.cctor()
+  IL_0000: ldc.i4.1
+  IL_0001: stsfld System.Int32 <Module>::a
+  IL_0006: ret
+
+System.Int32 <Module>::main()
+  IL_0000: sizeof System.Int32
+  IL_0006: ret
+
+System.Int32 <Module>::<SyntheticEntrypoint>()
+  Locals:
+    System.Int32 V_0
+  IL_0000: call System.Int32 <Module>::main()
+  IL_0005: stloc.s V_0
+  IL_0007: ldloc.s V_0
+  IL_0009: call System.Void Cesium.Runtime.RuntimeHelpers::Exit(System.Int32)
+  IL_000e: ldloc.s V_0
+  IL_0010: ret
diff --git a/Cesium.CodeGen.Tests/verified/CodeGenSizeofTests.IdentifierSizeof.verified.txt b/Cesium.CodeGen.Tests/verified/CodeGenSizeofTests.IdentifierSizeof.verified.txt
@@ -0,0 +1,17 @@
+System.Int32 <Module>::main()
+  Locals:
+    System.Int32 V_0
+  IL_0000: ldc.i4.1
+  IL_0001: stloc.0
+  IL_0002: sizeof System.Int32
+  IL_0008: ret
+
+System.Int32 <Module>::<SyntheticEntrypoint>()
+  Locals:
+    System.Int32 V_0
+  IL_0000: call System.Int32 <Module>::main()
+  IL_0005: stloc.s V_0
+  IL_0007: ldloc.s V_0
+  IL_0009: call System.Void Cesium.Runtime.RuntimeHelpers::Exit(System.Int32)
+  IL_000e: ldloc.s V_0
+  IL_0010: ret
diff --git a/Cesium.CodeGen/Extensions/ExpressionEx.cs b/Cesium.CodeGen/Extensions/ExpressionEx.cs
@@ -23,7 +23,8 @@ internal static class ExpressionEx
         Ast.IndirectionExpression e => new IndirectionExpression(e),
         Ast.UnaryOperatorExpression e => new UnaryOperatorExpression(e),
         Ast.CastExpression e => new TypeCastExpression(e),
-        Ast.SizeOfOperatorExpression e => new SizeOfOperatorExpression(e),
+        Ast.IdentifierSizeOfOperatorExpression e => new IdentifierSizeOfOperatorExpression(e),
+        Ast.TypeNameSizeOfOperatorExpression e => new TypeNameSizeOfOperatorExpression(e),
 
         // Binary operators:
         Ast.AssignmentExpression e => new AssignmentExpression(e),

diff --git a/Cesium.CodeGen/Ir/Expressions/IdentifierSizeOfOperatorExpression.cs b/Cesium.CodeGen/Ir/Expressions/IdentifierSizeOfOperatorExpression.cs
@@ -0,0 +1,31 @@
+using Cesium.CodeGen.Contexts;
+using Cesium.CodeGen.Extensions;
+using Cesium.CodeGen.Ir.Types;
+using Cesium.Core;
+
+namespace Cesium.CodeGen.Ir.Expressions;
+
+internal class IdentifierSizeOfOperatorExpression : IExpression
+{
+    private readonly IdentifierExpression _identifier;
+
+    public IdentifierSizeOfOperatorExpression(Ast.IdentifierSizeOfOperatorExpression astExpression)
+    {
+        var expression = astExpression.Identifier.ToIntermediate();
+
+        if (expression is not IdentifierExpression identifierExpression)
+            throw new CompilationException($"\"{astExpression.Identifier.Identifier}\" is not a valid identifier");
+        _identifier = identifierExpression;
+    }
+
+    public IExpression Lower(IDeclarationScope scope)
+    {
+        var typeResolved = _identifier.Resolve(scope).GetValueType();
+        var sizeOfExpression = new SizeOfOperatorExpression(typeResolved);
+        return sizeOfExpression.Lower(scope);
+    }
+
+    public void EmitTo(IEmitScope scope) => throw new AssertException("Should be lowered");
+
+    public IType GetExpressionType(IDeclarationScope scope) => throw new AssertException("Should be lowered");
+}
diff --git a/Cesium.CodeGen/Ir/Expressions/SizeOfOperatorExpression.cs b/Cesium.CodeGen/Ir/Expressions/SizeOfOperatorExpression.cs
@@ -1,8 +1,7 @@
-using Cesium.Ast;
 using Cesium.CodeGen.Contexts;
 using Cesium.CodeGen.Extensions;
-using Cesium.CodeGen.Ir.Declarations;
 using Cesium.CodeGen.Ir.Types;
+using Cesium.Core;
 
 namespace Cesium.CodeGen.Ir.Expressions;
 
@@ -15,34 +14,12 @@ public SizeOfOperatorExpression(IType Type)
         _type = Type;
     }
 
-    public SizeOfOperatorExpression(Ast.SizeOfOperatorExpression sizeOfOperator)
+    public IExpression Lower(IDeclarationScope scope) => _type switch
     {
-        var (specifiers, abstractDeclarator) = sizeOfOperator.TypeName;
-        _type = (specifiers, abstractDeclarator) switch
-        {
-            ({ }, { }) => LocalDeclarationInfo.Of(specifiers, abstractDeclarator).Type,
-            ({ }, null) => LocalDeclarationInfo.Of(specifiers, (Declarator?)null).Type
-        };
-    }
-
-    public IExpression Lower(IDeclarationScope scope)
-    {
-        if (_type is NamedType namedType)
-        {
-            var typeResolved = new IdentifierExpression(namedType.TypeName).Resolve(scope).GetValueType();
-            if (typeResolved is InPlaceArrayType typeArray)
-            {
-                return typeArray.GetSizeInBytesExpression(scope.ArchitectureSet);
-            }
-            return new SizeOfOperatorExpression(typeResolved);
-        }
-        else if (_type is InPlaceArrayType typeArray)
-        {
-            return typeArray.GetSizeInBytesExpression(scope.ArchitectureSet);
-        }
-        // TODO [#453]: If a struct is declared locally, it won't be resolved later, resulting in a failure.
-        return this;
-    } 
+        InPlaceArrayType arrayType => arrayType.GetSizeInBytesExpression(scope.ArchitectureSet),
+        StructType structType => throw new WipException(453, $"sizeof(StructType) not supported, yet: {structType.Identifier}."),
+        _ => this
+    };
 
     public void EmitTo(IEmitScope scope)
     {

diff --git a/Cesium.CodeGen/Ir/Expressions/TypeNameSizeOfOperatorExpression.cs b/Cesium.CodeGen/Ir/Expressions/TypeNameSizeOfOperatorExpression.cs
@@ -0,0 +1,32 @@
+using Cesium.Ast;
+using Cesium.CodeGen.Contexts;
+using Cesium.CodeGen.Ir.Declarations;
+using Cesium.CodeGen.Ir.Types;
+using Cesium.Core;
+
+namespace Cesium.CodeGen.Ir.Expressions;
+
+internal class TypeNameSizeOfOperatorExpression : IExpression
+{
+    private readonly IType _type;
+
+    public TypeNameSizeOfOperatorExpression(Ast.TypeNameSizeOfOperatorExpression expression)
+    {
+        var (specifiers, abstractDeclarator) = expression.TypeName;
+        _type = (specifiers, abstractDeclarator) switch
+        {
+            ({ }, { }) => LocalDeclarationInfo.Of(specifiers, abstractDeclarator).Type,
+            ({ }, null) => LocalDeclarationInfo.Of(specifiers, (Declarator?)null).Type
+        };
+    }
+
+    public IExpression Lower(IDeclarationScope scope)
+    {
+        var sizeOfExpression = new SizeOfOperatorExpression(_type);
+        return sizeOfExpression.Lower(scope);
+    }
+
+    public void EmitTo(IEmitScope scope) => throw new AssertException("Should be lowered");
+
+    public IType GetExpressionType(IDeclarationScope scope) => throw new AssertException("Should be lowered");
+}
diff --git a/Cesium.IntegrationTests/sizeof.c b/Cesium.IntegrationTests/sizeof.c
@@ -17,21 +17,6 @@ int testNamedTypeSizeof() {
     return 1;
 }
 
-struct foo {
-    int x;
-    int y;
-};
-
-int testGlobalStructSizeof() {
-    int structSize = sizeof(struct foo);
-
-    if (structSize != 8) {
-        return 0;
-    }
-
-    return 1;
-}
-
 int testCharSizeof() {
     if (sizeof(char) != 1) {
         return 0;
@@ -67,6 +52,27 @@ int testArrayLength() {
     return 1;
 }
 
+int testLocalEnumSizeOf() {
+    enum fooLocal {
+        bar
+    };
+
+    if (sizeof(enum fooLocal) != 4) {
+        return 0;
+    }
+    return 1;
+}
+
+enum foo {
+    bar
+};
+int testGlobalEnumSizeOf() {
+    if (sizeof(enum foo) != 4) {
+        return 0;
+    }
+    return 1;
+}
+
 // TODO [453]: Failing 
 //int testStructSizeof() {
 //    struct bar {
@@ -83,11 +89,26 @@ int testArrayLength() {
 //    return 1;
 //}
 
-// TODO [332]: Failing 
+// TODO[#332]: Failing 
 //int testStructSizeof() {
 //    return sizeof(int[5]);
 //}
 
+/// TODO[#453]: Struct can't be resolved
+//struct foo {
+//    int x;
+//    int y;
+//};
+//int testGlobalStructSizeof() {
+//    int structSize = sizeof(struct foo);
+//
+//    if (structSize != 8) {
+//        return 0;
+//    }
+//
+//    return 1;
+//}
+
 int main(int argc, char* argv[])
 {
     if (!testPrimitiveTypeSizeof()) {
@@ -98,9 +119,9 @@ int main(int argc, char* argv[])
         return -2;
     }
 
-    if (!testGlobalStructSizeof()) {
-        return -3;
-    }
+    //if (!testGlobalStructSizeof()) {
+    //    return -3;
+    //}
 
     if (!testCharSizeof()) {
         return -4;
@@ -118,5 +139,13 @@ int main(int argc, char* argv[])
         return -7;
     }
 
+    if (!testLocalEnumSizeOf()) {
+        return -8;
+    }
+
+    if (!testGlobalEnumSizeOf()) {
+        return -9;
+    }
+
     return 42;
 }
diff --git a/Cesium.Parser/CParser.cs b/Cesium.Parser/CParser.cs
@@ -188,9 +188,13 @@ private static Expression MakeUnaryOperatorExpression(ICToken @operator, Express
     [Rule("unary_operator: '!'")]
     private static ICToken MakeUnaryOperator(ICToken @operator) => @operator;
 
+    [Rule("unary_expression: KeywordSizeof '(' Identifier ')'")]
+    private static Expression MakeTypeNameSizeOfOperator(ICToken _, ICToken __, IToken identifier, ICToken ___) =>
+        new IdentifierSizeOfOperatorExpression(new IdentifierExpression(identifier.Text));
+
     [Rule("unary_expression: KeywordSizeof '(' type_name ')'")]
-    private static Expression MakeTypeNameSizeOfOperator(ICToken _, ICToken __, TypeName target, ICToken ___) =>
-        new SizeOfOperatorExpression(target);
+    private static Expression MakeTypeSpecifierSizeOfOperator(ICToken _, ICToken __, TypeName typeName, ICToken ___) =>
+        new TypeNameSizeOfOperatorExpression(typeName);
 
     // 6.5.4 Cast operators
     [Rule("cast_expression: '(' type_name ')' cast_expression")]