Merge pull request #272 from vein-lang/feature/vritual-call

0xF6 · web-flow · commit 543dbda5b2b3 · 2024-08-14T06:00:41.000+03:00
Support calling method virtual\abstract based on vtable
diff --git a/lib/vein.std/std/aspects/Aspect.vein b/lib/vein.std/std/aspects/Aspect.vein
@@ -1,7 +1,7 @@
 #space "std"
 
 [special, forwarded]
-public class Aspect : Object 
+public abstract class Aspect : Object 
 {
     public static USAGE_METHOD: i32 = 1 << 1;
     public static USAGE_CLASS: i32 = 1 << 2;
diff --git a/metadata/db_opcodes.json b/metadata/db_opcodes.json
@@ -117,5 +117,6 @@
   "LDFN": 115,
   "LD_TYPE.G": 116,
   "CAST.G": 117,
-  "LD_TYPE.E": 118
+  "LD_TYPE.E": 118,
+  "CALL_V": 119
 }
diff --git a/metadata/opcodes.def.cs b/metadata/opcodes.def.cs
@@ -210,6 +210,10 @@ public enum OpCodeValue : ushort
 	/// </summary>
 	CALL = 0x32,
 	/// <summary>
+	/// Call operation (abstract and virtual only).
+	/// </summary>
+	CALL_V = 0x77,
+	/// <summary>
 	/// Call operation (load pointer from stack).
 	/// </summary>
 	CALL_SP = 0x72,
diff --git a/metadata/opcodes.list.def.cs b/metadata/opcodes.list.def.cs
@@ -6,7 +6,7 @@ namespace ishtar
 	using System.Collections.Generic;
 	public static class OpCodes 
 	{
-		internal static int SetVersion = 25;
+		internal static int SetVersion = 26;
 		/// <summary>
 		/// Nope operation.
 		/// size: 0
@@ -365,6 +365,13 @@ public static class OpCodes
 		/// </summary>
 		public static readonly OpCode CALL = new (0x32, 0x0200001F);
 		/// <summary>
+		/// Call operation (abstract and virtual only).
+		/// size: 8
+		/// flow: 0
+		/// chain: 0
+		/// </summary>
+		public static readonly OpCode CALL_V = new (0x77, 0x0200001F);
+		/// <summary>
 		/// Call operation (load pointer from stack).
 		/// size: 0
 		/// flow: 0
@@ -894,6 +901,7 @@ public static class OpCodes
 			{OpCodeValue.RESERVED_2, RESERVED_2},
 			{OpCodeValue.RET, RET},
 			{OpCodeValue.CALL, CALL},
+			{OpCodeValue.CALL_V, CALL_V},
 			{OpCodeValue.CALL_SP, CALL_SP},
 			{OpCodeValue.LDFN, LDFN},
 			{OpCodeValue.LDNULL, LDNULL},
diff --git a/metadata/opcodes.yaml b/metadata/opcodes.yaml
@@ -56,6 +56,9 @@
 - CALL:
     description: Call operation.
     override-size: 8
+- CALL_V:
+    description: Call operation (abstract and virtual only).
+    override-size: 8
 - CALL_SP:
     description: Call operation (load pointer from stack).
 - LDFN:
diff --git a/metadata/version b/metadata/version
@@ -1 +1 @@
-25
+26
diff --git a/runtime/ishtar.base/emit/ILGenerator.cs b/runtime/ishtar.base/emit/ILGenerator.cs
@@ -361,6 +361,10 @@ public ILGenerator Emit(OpCode opcode, VeinMethod method)
             if (opcode != OpCodes.CALL && opcode != OpCodes.LDFN)
                 throw new InvalidOpCodeException($"Opcode '{opcode.Name}' is not allowed.");
 
+            // for automatic change CALL opcode to CALL_V 
+            if (opcode == OpCodes.CALL && (method.IsVirtual || method.IsAbstract))
+                opcode = OpCodes.CALL_V;
+
             using var _ = ILCapacityValidator.Begin(ref _position, opcode);
 
             var (tokenIdx, ownerIdx) = this._methodBuilder.classBuilder.moduleBuilder.GetMethodToken(method);
diff --git a/runtime/ishtar.generator/GeneratorContext.cs b/runtime/ishtar.generator/GeneratorContext.cs
@@ -237,7 +237,7 @@ public VeinClass CreateFunctionMulticastGroup(VeinMethodSignature sig)
                 true, true);
 
         var hiddenClass = CurrentScope.Context
-            .CreateHiddenType($"fn_{string.Join(' ', Encoding.UTF8.GetBytes(sig.ToTemplateString()).Select(x => $"{x:X}"))}", @base);
+            .CreateHiddenType($"fn_{Convert.ToBase64String(Encoding.UTF8.GetBytes(sig.ToTemplateString()))}", @base);
 
         if (hiddenClass.TypeCode is TYPE_FUNCTION)
             return hiddenClass;
@@ -284,8 +284,9 @@ public VeinClass CreateFunctionMulticastGroup(VeinMethodSignature sig)
             generator.EmitThis();
             generator.Emit(OpCodes.LDF, scope);
         }
+
         foreach (int i in ..method.Signature.ArgLength)
-            generator.Emit(OpCodes.LDARG_S, i + 1); // TODO optimization for LDARG_X
+            generator.EmitLoadArgument(i + 1); //generator.Emit(OpCodes.LDARG_S, i + 1);
 
         generator.EmitThis();
         generator.Emit(OpCodes.LDF, ptrRef);
diff --git a/runtime/ishtar.generator/generators/access.cs b/runtime/ishtar.generator/generators/access.cs
@@ -39,6 +39,18 @@ public static ILGenerator EmitStageField(this ILGenerator gen, VeinField field)
         5 => gen.Emit(OpCodes.LDARG_5),
         _ => gen.Emit(OpCodes.LDARG_S, i)
     };
+
+    public static ILGenerator EmitStageLocal(this ILGenerator gen, int i) => i switch
+    {
+        0 => gen.Emit(OpCodes.STLOC_0),
+        1 => gen.Emit(OpCodes.STLOC_1),
+        2 => gen.Emit(OpCodes.STLOC_2),
+        3 => gen.Emit(OpCodes.STLOC_3),
+        4 => gen.Emit(OpCodes.STLOC_4),
+        5 => gen.Emit(OpCodes.STLOC_5),
+        _ => gen.Emit(OpCodes.STLOC_S, i)
+    };
+
     public static ILGenerator EmitLoadIdentifierReference(this ILGenerator gen, IdentifierExpression id)
     {
         var context = gen.ConsumeFromMetadata<GeneratorContext>("context");
@@ -48,7 +60,7 @@ public static ILGenerator EmitLoadIdentifierReference(this ILGenerator gen, Iden
         {
             var (type, index) = context.CurrentScope.GetVariable(id);
             gen.WriteDebugMetadata($"/* access local, var: '{id}', index: '{index}', type: '{type}' */");
-            return gen.Emit(OpCodes.LDLOC_S, index);
+            return gen.EmitLoadLocal(index);
         }
 
         // second order: search argument
@@ -250,7 +262,7 @@ public static ILGenerator EmitAccess(this ILGenerator gen, AccessExpressionSynta
         }
 
         if (access is { Left: ThisAccessExpression, Right: InvocationExpression inv1 })
-            return gen.EmitCall(ctx.CurrentMethod.Owner, inv1);
+            return gen.EmitThis().EmitCall(ctx.CurrentMethod.Owner, inv1);
         if (access is { Left: SelfAccessExpression, Right: InvocationExpression inv2 })
             return gen.EmitCall(ctx.CurrentMethod.Owner, inv2);
 
diff --git a/runtime/ishtar.generator/generators/local.cs b/runtime/ishtar.generator/generators/local.cs
@@ -64,7 +64,7 @@ public static void EmitLocalVariableWithType(this ILGenerator generator, LocalVa
         scope.DefineVariable(localVar.Identifier, type, locIndex);
 
         generator.Emit(OpCodes.LDNULL);
-        generator.Emit(OpCodes.STLOC_S, locIndex); // TODO optimization for STLOC_0,1,2 and etc
+        generator.EmitStageLocal(locIndex);
     }
 
     public static void EmitLocalVariable(this ILGenerator generator, LocalVariableDeclaration localVar)
diff --git a/runtime/ishtar.generator/generators/operators.cs b/runtime/ishtar.generator/generators/operators.cs
@@ -316,7 +316,8 @@ public static ILGenerator EmitUnary(this ILGenerator gen, UnaryExpressionSyntax
             }
             else
                 throw new NotSupportedException("EmitLoadFunction");
-            gen.Emit(OpCodes.LDNULL);
+
+            gen.EmitThis(); // todo, check method ref from another scopes 
 
             var ctor = fnType.FindMethod(VeinMethod.METHOD_NAME_CONSTRUCTOR,
             [
diff --git a/runtime/ishtar.vm/vm.entry.cs b/runtime/ishtar.vm/vm.entry.cs
@@ -66,59 +66,12 @@
 
     var watcher = Stopwatch.StartNew();
 
-    //var debugModules = new DirectoryInfo("./modules");
-
-    //if (!debugModules.Exists)
-    //    debugModules.Create();
-
-    //IshtarSharedDebugData.DumpToFile(new FileInfo($"./modules/{module->Name}.module"), IshtarTrace.Dump(module));
-
-    //module->deps_table->ForEach(x =>
-    //{
-    //    IshtarSharedDebugData.DumpToFile(new FileInfo($"./modules/{x->Name}.module"), IshtarTrace.Dump(x));
-    //});
-
     vm->task_scheduler->start_threading(module);
     vm->task_scheduler->execute_method(frame);
 
-    if (!frame->exception.IsDefault())
-    {
-        var exceptionValue = frame->exception.value;
-        var exceptionClass = exceptionValue->clazz;
-
-        if (exceptionClass->FindField("message") is null)
-        {
-            vm->trace.error($"unhandled exception '{frame->exception.value->clazz->Name}' was thrown. \n" +
-                           $"{frame->exception.GetStackTrace()}");
-        }
-        else
-        {
-            var msg = exceptionValue->vtable[exceptionClass->Field["message"]->vtable_offset];
-            if (msg is null)
-            {
-                vm->trace.error($"unhandled exception '{frame->exception.value->clazz->Name}' was thrown. \n" +
-                               $"{frame->exception.GetStackTrace()}");
-            }
-            else
-            {
-                var message = IshtarMarshal.ToDotnetString((IshtarObject*)msg, frame);
-                vm->trace.error(
-                    $"""
-                     unhandled exception '{frame->exception.value->clazz->Name}' was thrown.
-                     '{message}'
-                     {frame->exception.GetStackTrace()}
-                     """);
-            }
-        }
-    }
-
     watcher.Stop();
     vm->trace.log($"Elapsed: {watcher.Elapsed}");
     frame->Dispose();
     vm->Dispose();
-
-    vm->trace.log($"Press ENTER to exit...");
-
-    Console.ReadKey();
     return 0;
 }
diff --git a/runtime/ishtar.vm/vm.loop.cs b/runtime/ishtar.vm/vm.loop.cs
@@ -49,6 +49,8 @@ void jump_to(int index, uint* start, ref uint* ip, MetaMethodHeader* mh, CallFra
 
     public void exec_method(CallFrame* invocation)
     {
+        FastFail(invocation->method is null, ACCESS_VIOLATION, "unexpected call frame method pointer corrupted.", invocation);
+        FastFail((invocation->method->Flags & MethodFlags.Abstract) != 0, EXECUTION_CORRUPTED, "unexpected call abstract method", invocation);
         if (!@ref->Config.DisableValidationInvocationArgs)
         {
             var argsLen = invocation->method->ArgLength;
@@ -163,6 +165,7 @@ public void exec_method(CallFrame* invocation)
                     println($"load from args ({sp->type})");
                     Assert(sp->type != TYPE_NONE, STATE_CORRUPT, "", invocation);
                     Assert(sp->type <= TYPE_NULL, STATE_CORRUPT, "", invocation);
+                    Assert(sp->type == TYPE_CLASS, sp->data.p != 0, STATE_CORRUPT, "", invocation);
                     ++sp;
                     ++ip;
                     break;
@@ -172,6 +175,7 @@ public void exec_method(CallFrame* invocation)
                     println($"load from args ({sp->type})");
                     Assert(sp->type != TYPE_NONE, STATE_CORRUPT, "", invocation);
                     Assert(sp->type <= TYPE_NULL, STATE_CORRUPT, "", invocation);
+                    Assert(sp->type == TYPE_CLASS, sp->data.p != 0, STATE_CORRUPT, "", invocation);
                     ++sp;
                     ++ip;
                     break;
@@ -372,12 +376,15 @@ public void exec_method(CallFrame* invocation)
 
                     if (!@ref->Config.SkipValidateStfType || !field->FieldType.IsGeneric)
                     {
-                        if (value->type != TYPE_NULL && field->FieldType.Class->TypeCode != value->type)
+                        if ((value->type != TYPE_NULL) && field->FieldType.Class->TypeCode != value->type)
                         {
-                            CallFrame.FillStackTrace(invocation);
-                            ForceThrow(KnowTypes.IncorrectCastFault(invocation), sp, invocation,
-                                $"Cannot cast '{value->type}' to '{field->FieldType.Class->TypeCode}', maybe invalid IL");
-                            goto exception_handle;
+                            if (field->FieldType.Class->TypeCode != TYPE_OBJECT || value->type != TYPE_CLASS)
+                            {
+                                CallFrame.FillStackTrace(invocation);
+                                ForceThrow(KnowTypes.IncorrectCastFault(invocation), sp, invocation,
+                                    $"Cannot cast '{value->type}' to '{field->FieldType.Class->TypeCode}', maybe invalid IL");
+                                goto exception_handle;
+                            }
                         }
                     }
 
@@ -555,6 +562,7 @@ public void exec_method(CallFrame* invocation)
                     sp->data.p = (nint)raw;
                     ++sp;
                 } break;
+                case CALL_V:
                 case CALL_SP:
                 case CALL:
                 {
@@ -568,8 +576,41 @@ public void exec_method(CallFrame* invocation)
                         method = GetMethod(tokenIdx, owner, _module, invocation);
                         ++ip;
                     }
+                    else if (invocation->last_ip == CALL_V)
+                    {
+                        ++ip;
+                        var tokenIdx = *ip;
+                        var owner = readTypeName(*++ip, _module, invocation);
+
+                        var targetMethod = GetMethod(tokenIdx, owner, _module, invocation);
+
+                        Assert((targetMethod->Flags & MethodFlags.Static) == 0, TYPE_MISMATCH, "call.v fail", invocation);
+
+                        // take this* ref from stack for getting overrides method from vtable
+                        var shiftSp = sp - targetMethod->ArgLength;
+
+                        if (shiftSp->type == TYPE_NULL)
+                        {
+                            @ref->ForceThrow(KnowTypes.NullPointerException(invocation), sp, invocation);
+                            goto exception_handle;
+                            return;
+                        }
+
+                        ++ip;
+                        Assert(shiftSp->type == targetMethod->Owner->TypeCode, TYPE_MISMATCH, "call.v fail", invocation);
+                        var targetObj = (IshtarObject*)shiftSp->data.p;
+
+                        Assert(shiftSp->type == TYPE_CLASS, targetObj != null, GC_MOVED_UNMOVABLE_MEMORY, "closure scope deleted", invocation);
+
+                        if (!IshtarObject.IsAssignableFrom(invocation, targetObj->clazz, targetMethod->Owner))
+                        {
+                            Assert(false, TYPE_MISMATCH, "call.v fail", invocation);
+                            return;
+                        }
 
-                    if (invocation->last_ip == CALL_SP)
+                        method = (RuntimeIshtarMethod*)targetObj->vtable[targetMethod->vtable_offset];
+                    }
+                    else if (invocation->last_ip == CALL_SP)
                     {
                         ++ip;
                         sp--;
@@ -590,8 +631,18 @@ public void exec_method(CallFrame* invocation)
                         Assert(raw->type == VeinRawCode.ISHTAR_METHOD, MISSING_TYPE, "", invocation);
                         method = raw->data.m;
                     }
-                        
+                    else
+                        FastFail(true, EXECUTION_CORRUPTED,
+                            "incorrect opcode behaviour", invocation);
 
+                    if (invocation->last_ip != CALL_V)
+                    {
+                        FastFail((method->Flags & MethodFlags.Abstract) != 0, EXECUTION_CORRUPTED,
+                            "opcode CALL/CALL_SP cannot execute abstract method", invocation);
+                        FastFail((method->Flags & MethodFlags.Virtual) != 0, EXECUTION_CORRUPTED,
+                            "opcode CALL/CALL_SP cannot execute virtual method", invocation);
+                    }
+                    
                     var child_frame = invocation->CreateChild(method);
                     println($".call {method->Owner->Name}::{method->Name}");
                     var method_args = gc->AllocateStack(child_frame, method->ArgLength);
@@ -639,7 +690,7 @@ public void exec_method(CallFrame* invocation)
 
                         if (sp->type > TYPE_NULL)
                             FastFail(STATE_CORRUPT, $"[call arg validation] trying fill corrupted argument [{y}/{method->ArgLength}] for [{method->Name}]", invocation);
-
+                        Assert(sp->type == TYPE_CLASS, sp->data.p != 0, GC_MOVED_UNMOVABLE_MEMORY, "argument incorrect, maybe gc dropped memory from callframe", invocation);
                         method_args[y] = *sp;
                     }
 
@@ -1211,10 +1262,47 @@ void fill_frame_exception()
             else
             {
                 fill_frame_exception();
+                if (invocation->level == 0)
+                    handle_unhandled_exception(invocation);
                 return;
             }
 
             goto vm_cycle_start;
         }
     }
+
+    private void handle_unhandled_exception(CallFrame* frame)
+    {
+        if (!frame->exception.IsDefault())
+        {
+            var exceptionValue = frame->exception.value;
+            var exceptionClass = exceptionValue->clazz;
+
+            if (exceptionClass->FindField("message") is null)
+            {
+                trace.error($"unhandled exception '{frame->exception.value->clazz->Name}' was thrown. \n" +
+                                $"{frame->exception.GetStackTrace()}");
+            }
+            else
+            {
+                var msg = exceptionValue->vtable[exceptionClass->Field["message"]->vtable_offset];
+                if (msg is null)
+                {
+                    trace.error($"unhandled exception '{frame->exception.value->clazz->Name}' was thrown. \n" +
+                                    $"{frame->exception.GetStackTrace()}");
+                }
+                else
+                {
+                    var message = IshtarMarshal.ToDotnetString((IshtarObject*)msg, frame);
+                    trace.error(
+                        $"""
+                         unhandled exception '{frame->exception.value->clazz->Name}' was thrown.
+                         '{message}'
+                         {frame->exception.GetStackTrace()}
+                         """);
+                }
+            }
+            halt();
+        }
+    }
 }
diff --git a/runtime/ishtar.vm/vm.utils.cs b/runtime/ishtar.vm/vm.utils.cs
diff --git a/tools/compiler/compilation/parts/methods.cs b/tools/compiler/compilation/parts/methods.cs

Original file line number	Diff line number	Diff line change
`@@ -1,7 +1,7 @@`
`1`	`1`	`#space "std"`
`2`	`2`
`3`	`3`	`[special, forwarded]`
`4`		`-public class Aspect : Object`
	`4`	`+public abstract class Aspect : Object`
`5`	`5`	`{`
`6`	`6`	`public static USAGE_METHOD: i32 = 1 << 1;`
`7`	`7`	`public static USAGE_CLASS: i32 = 1 << 2;`
Original file line number	Diff line number	Diff line change
`@@ -117,5 +117,6 @@`
`117`	`117`	`"LDFN": 115,`
`118`	`118`	`"LD_TYPE.G": 116,`
`119`	`119`	`"CAST.G": 117,`
`120`		`- "LD_TYPE.E": 118`
	`120`	`+ "LD_TYPE.E": 118,`
	`121`	`+ "CALL_V": 119`
`121`	`122`	`}`
Original file line number	Diff line number	Diff line change
`@@ -64,7 +64,7 @@ public static void EmitLocalVariableWithType(this ILGenerator generator, LocalVa`
`64`	`64`	`scope.DefineVariable(localVar.Identifier, type, locIndex);`
`65`	`65`
`66`	`66`	`generator.Emit(OpCodes.LDNULL);`
`67`		`- generator.Emit(OpCodes.STLOC_S, locIndex); // TODO optimization for STLOC_0,1,2 and etc`
	`67`	`+ generator.EmitStageLocal(locIndex);`
`68`	`68`	`}`
`69`	`69`
`70`	`70`	`public static void EmitLocalVariable(this ILGenerator generator, LocalVariableDeclaration localVar)`