Initialize using address of compound initializer (#718)

ForNeVeR · Nov 22, 2024 · 03ebc93 · 03ebc93
1 parent f31e852
commit 03ebc93
Show file tree

Hide file tree

Showing 12 changed files with 84 additions and 26 deletions.
diff --git a/Cesium.CodeGen.Tests/CodeGenEnumTests.cs b/Cesium.CodeGen.Tests/CodeGenEnumTests.cs
@@ -99,5 +99,12 @@ enum Colour { Red, Green, Blue };
     public Task EnumUseValuesInDeclaration() => DoTest(@"
 enum Colour { Red, Green, Blue = Green + 10 };
 int x = {Blue};
+");
+
+    [Fact]
+    public Task EnumUseValuesInStructPointerDeclaration() => DoTest(@"
+enum Colour { Red, Green, Blue = Green + 10 };
+typedef struct  { int x; } TestStruct;
+TestStruct *x = &(TestStruct){Blue};
 ");
 }
diff --git a/...eGen.Tests/verified/CodeGenEnumTests.EnumUseValuesInStructPointerDeclaration.verified.txt b/...eGen.Tests/verified/CodeGenEnumTests.EnumUseValuesInStructPointerDeclaration.verified.txt
@@ -0,0 +1,13 @@
+System.Void <Module>::.cctor()
+  Locals:
+    <typedef>TestStruct V_0
+  IL_0000: ldloca V_0
+  IL_0004: initobj <typedef>TestStruct
+  IL_000a: ldloca V_0
+  IL_000e: ldc.i4.s 11
+  IL_0010: stfld System.Int32 <typedef>TestStruct::x
+  IL_0015: ldloc V_0
+  IL_0019: stsfld <typedef>TestStruct <Module>::global_tmp_0
+  IL_001e: ldsflda <typedef>TestStruct <Module>::global_tmp_0
+  IL_0023: stsfld <typedef>TestStruct* <Module>::x
+  IL_0028: ret
diff --git a/Cesium.CodeGen/Contexts/BlockScope.cs b/Cesium.CodeGen/Contexts/BlockScope.cs
@@ -114,4 +114,7 @@ public void PushPragma(IPragma blockItem) { }
 
     /// <inheritdoc />
     public void RemovePragma<T>(Predicate<T> predicate) where T : IPragma { }
+
+    /// <inheritdoc />
+    public string GetTmpVariable() => ((IDeclarationScope)Parent).GetTmpVariable();
 }
diff --git a/Cesium.CodeGen/Contexts/FunctionScope.cs b/Cesium.CodeGen/Contexts/FunctionScope.cs
@@ -138,4 +138,12 @@ public void MergeScope(BlockScope scope)
             _variableDefinition.Add(variableName, variableDefinition);
         }
     }
+
+    private int tempLocalIndex = 0;
+
+    /// <inheritdoc />
+    public string GetTmpVariable()
+    {
+        return "local_" + tempLocalIndex++;
+    }
 }
diff --git a/Cesium.CodeGen/Contexts/GlobalConstructorScope.cs b/Cesium.CodeGen/Contexts/GlobalConstructorScope.cs
@@ -100,4 +100,12 @@ public void RemovePragma<T>(Predicate<T> predicate) where T : IPragma
             }
         }
     }
+
+    private int tempLocalIndex = 0;
+
+    /// <inheritdoc />
+    public string GetTmpVariable()
+    {
+        return "global_tmp_" + tempLocalIndex++;
+    }
 }
diff --git a/Cesium.CodeGen/Contexts/IDeclarationScope.cs b/Cesium.CodeGen/Contexts/IDeclarationScope.cs
@@ -64,4 +64,10 @@ internal interface IDeclarationScope
     void RemovePragma<T>(Predicate<T> predicate) where T : IPragma;
 
     List<SwitchCase>? SwitchCases { get; }
+
+    /// <summary>
+    /// Gets name of the new temp variable.
+    /// </summary>
+    /// <returns>Name of the new temporary variable, unique to the scope</returns>
+    string GetTmpVariable();
 }
diff --git a/Cesium.CodeGen/Extensions/ExpressionEx.cs b/Cesium.CodeGen/Extensions/ExpressionEx.cs
@@ -39,6 +39,7 @@ internal static class ExpressionEx
         Ast.MemberAccessExpression e => new MemberAccessExpression(e),
         Ast.PointerMemberAccessExpression e => new PointerMemberAccessExpression(e),
         Ast.PostfixIncrementDecrementExpression e => new PostfixIncrementDecrementExpression(e),
+        Ast.CompoundLiteralExpression e => new CompoundObjectInitializationExpression(e),
 
         Ast.CommaExpression e => new CommaExpression(e),
 

diff --git a/Cesium.CodeGen/Extensions/TranslationUnitEx.cs b/Cesium.CodeGen/Extensions/TranslationUnitEx.cs
@@ -57,7 +57,24 @@ private static IEnumerable<IBlockItem> GetTopLevelDeclarations(Ast.SymbolDeclara
                             if (initializer != null)
                             {
                                 var variableIdentifier = new IdentifierExpression(identifier);
-                                yield return new ExpressionStatement(new AssignmentExpression(variableIdentifier, AssignmentOperator.Assign, initializer, false));
+                                if (initializer is UnaryOperatorExpression { Operator : UnaryOperator.AddressOf, Target: CompoundObjectInitializationExpression compoundInitializationExpression } unaryOperatorExpression)
+                                {
+                                    var tempVariableName = scope.GetTmpVariable();
+                                    var tempVariableIdentifier = new IdentifierExpression(tempVariableName);
+                                    if (type is PointerType pointerType)
+                                    {
+                                        type = pointerType.Base;
+                                    }
+
+                                    var tempVariable = new GlobalVariableDefinition(storageClass, type, tempVariableName);
+                                    yield return tempVariable;
+                                    yield return new ExpressionStatement(new AssignmentExpression(tempVariableIdentifier, AssignmentOperator.Assign, compoundInitializationExpression, false));
+                                    yield return new ExpressionStatement(new AssignmentExpression(variableIdentifier, AssignmentOperator.Assign, new UnaryOperatorExpression(UnaryOperator.AddressOf, tempVariableIdentifier), false));
+                                }
+                                else
+                                {
+                                    yield return new ExpressionStatement(new AssignmentExpression(variableIdentifier, AssignmentOperator.Assign, initializer, false));
+                                }
                             }
 
                             continue;

diff --git a/Cesium.CodeGen/Ir/Declarations/LocalDeclarationInfo.cs b/Cesium.CodeGen/Ir/Declarations/LocalDeclarationInfo.cs
@@ -56,7 +56,7 @@ public static LocalDeclarationInfo Of(
         return new LocalDeclarationInfo(type, Identifier: null, cliImportMemberName);
     }
 
-    private static (IType, string? CliImportMemberName) ProcessSpecifiers(
+    public static (IType, string? CliImportMemberName) ProcessSpecifiers(
         IReadOnlyList<IDeclarationSpecifier> specifiers)
     {
         IType? type = null;

diff --git a/Cesium.CodeGen/Ir/Declarations/ScopedDeclarationInfo.cs b/Cesium.CodeGen/Ir/Declarations/ScopedDeclarationInfo.cs
@@ -83,7 +83,6 @@ private static ScopedIdentifierDeclaration[] IdentifierOf(
         var declarations = initDeclarators
             .Select(id =>
             {
-                //return IdentifierOf(declarationSpecifiers, id);
                 var (declarator, initializer) = id;
                 var declarationInfo = LocalDeclarationInfo.Of(declarationSpecifiers, declarator, initializer);
                 var (type, _, _) = declarationInfo;
@@ -94,18 +93,7 @@ private static ScopedIdentifierDeclaration[] IdentifierOf(
         return declarations;
     }
 
-    private static InitializableDeclarationInfo IdentifierOf(
-        IReadOnlyList<IDeclarationSpecifier> specifiers,
-        InitDeclarator initDeclarator)
-    {
-        var (declarator, initializer) = initDeclarator;
-        var declarationInfo = LocalDeclarationInfo.Of(specifiers, declarator, initializer);
-        var (type, _, _) = declarationInfo;
-        var expression = ConvertInitializer(type, initializer);
-        return new InitializableDeclarationInfo(declarationInfo, expression);
-    }
-
-    private static IExpression? ConvertInitializer(Types.IType? type, Initializer? initializer)
+    public static IExpression? ConvertInitializer(Types.IType? type, Initializer? initializer)
     {
         if (initializer is null)
         {

diff --git a/Cesium.CodeGen/Ir/Expressions/CompoundObjectFieldInitializer.cs b/Cesium.CodeGen/Ir/Expressions/CompoundObjectFieldInitializer.cs
@@ -20,9 +20,15 @@ internal CompoundObjectFieldInitializer(AssignmentInitializer initializer)
         Designation = initializer.Designation!;
     }
 
+    internal CompoundObjectFieldInitializer(IExpression inner, Designation designation)
+    {
+        Inner = inner;
+        Designation = designation;
+    }
+
     public void EmitTo(IEmitScope scope) => Inner.EmitTo(scope);
 
     public IType GetExpressionType(IDeclarationScope scope) => Inner.GetExpressionType(scope);
 
-    public IExpression Lower(IDeclarationScope scope) => Inner.Lower(scope);
+    public IExpression Lower(IDeclarationScope scope) => new CompoundObjectFieldInitializer(Inner.Lower(scope), Designation);
 }
diff --git a/Cesium.CodeGen/Ir/Expressions/CompoundObjectInitializationExpression.cs b/Cesium.CodeGen/Ir/Expressions/CompoundObjectInitializationExpression.cs
@@ -1,6 +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;
 using Mono.Cecil;
@@ -15,7 +16,6 @@ internal sealed class CompoundObjectInitializationExpression : IExpression
     private Action? _prefixAction;
     private Action? _postfixAction;
     private readonly ImmutableArray<IExpression?> _initializers;
-    private IDeclarationScope? _scope;
 
     public CompoundObjectInitializationExpression(IType type, ImmutableArray<IExpression?> initializers)
     {
@@ -28,6 +28,13 @@ public CompoundObjectInitializationExpression(ImmutableArray<IExpression?> initi
         _initializers = initializers;
     }
 
+    public CompoundObjectInitializationExpression(Ast.CompoundLiteralExpression expression)
+    {
+        var (type, cliDescription) = LocalDeclarationInfo.ProcessSpecifiers(expression.TypeName.SpecifierQualifierList);
+        _type = type;
+        _initializers = expression.Initializers.Select(initializer => IScopedDeclarationInfo.ConvertInitializer(_type, initializer)).ToImmutableArray();
+    }
+
     public void Hint(FieldDefinition type, Action prefixAction, Action postfixAction)
     {
         _typeDef = type;
@@ -271,14 +278,8 @@ static Instruction GetWriteInstruction(MetadataType type)
 
     public IExpression Lower(IDeclarationScope scope)
     {
-        _scope = scope;
-        if (_type != null) CheckIfResolved(scope);
-        return this;
-    }
-
-    private void CheckIfResolved(IDeclarationScope scope)
-    {
-        if (_type!.TypeKind == TypeKind.Unresolved)
-            _type = scope.ResolveType(_type);
+        var resolvedType = _type?.TypeKind == TypeKind.Unresolved ? scope.ResolveType(_type) : _type;
+        var initializers = _initializers.Select(_ => _?.Lower(scope)).ToImmutableArray();
+        return resolvedType == null ? new CompoundObjectInitializationExpression(initializers) : new CompoundObjectInitializationExpression(resolvedType, initializers);
     }
 }