Wasm enable shared generics and generic virtual methods

src/Common/src/Internal/Runtime/RuntimeConstants.cs

@@ -4,15 +4,6 @@
 
 namespace Internal.Runtime
 {
-    internal static class FatFunctionPointerConstants
-    {
-        /// <summary>
-        /// Offset by which fat function pointers are shifted to distinguish them
-        /// from real function pointers.
-        /// </summary>
-        public const int Offset = 2;
-    }
-
     internal static class IndirectionConstants
     {
         /// <summary>

src/Common/src/TypeSystem/Aot/TargetDetails.Aot.cs

@@ -0,0 +1,17 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for more information.
+
+namespace Internal.TypeSystem
+{
+    // Extension to TargetDetails related to Aot
+    partial class TargetDetails
+    {
+        /// <summary>
+        /// Offset by which fat function pointers are shifted to distinguish them
+        /// from real function pointers.
+        /// WebAssembly uses index tables, not addresses for function pointers, so the lower bits are not free to use.  
+        /// </summary>
+        public int FatFunctionPointerOffset => Architecture == TargetArchitecture.Wasm32 ? 1 << 31 : 2;
+    }
+}

src/Common/src/TypeSystem/IL/ILImporter.cs

@@ -575,7 +575,7 @@ private void ImportBasicBlock(BasicBlock basicBlock)
                         ImportConvert(WellKnownType.UInt32, false, false);
                         break;
                     case ILOpcode.conv_u8:
-                        ImportConvert(WellKnownType.UInt64, false, false);
+                        ImportConvert(WellKnownType.UInt64, false, true);
                         break;
                     case ILOpcode.callvirt:
                         ImportCall(opCode, ReadILToken());

src/ILCompiler.Compiler/src/Compiler/DependencyAnalysis/CanonicalEETypeNode.cs

@@ -16,7 +16,7 @@ namespace ILCompiler.DependencyAnalysis
     /// they are used by the dynamic type loader when dynamically instantiating types at runtime.
     /// The data that we emit on canonical type instantiations should just be the minimum that is needed by the template 
     /// type loader. 
-    /// Similarly, the dependencies that we track for canonicl type instantiations are minimal, and are just the ones used
+    /// Similarly, the dependencies that we track for canonical type instantiations are minimal, and are just the ones used
     /// by the dynamic type loader
     /// </summary>
     public sealed class CanonicalEETypeNode : EETypeNode

src/ILCompiler.Compiler/src/Compiler/DependencyAnalysis/FatFunctionPointerNode.cs

@@ -6,7 +6,6 @@
 using Internal.TypeSystem;
 
 using Debug = System.Diagnostics.Debug;
-using FatFunctionPointerConstants = Internal.Runtime.FatFunctionPointerConstants;
 
 namespace ILCompiler.DependencyAnalysis
 {
@@ -37,7 +36,7 @@ public void AppendMangledName(NameMangler nameMangler, Utf8StringBuilder sb)
         }
 
         int ISymbolDefinitionNode.Offset => 0;
-        int ISymbolNode.Offset => FatFunctionPointerConstants.Offset;
+        int ISymbolNode.Offset => Method.Context.Target.FatFunctionPointerOffset;
 
         public override bool IsShareable => true;
 

src/ILCompiler.Compiler/src/Compiler/DependencyAnalysis/ReflectionInvokeMapNode.cs

@@ -9,7 +9,6 @@
 using Internal.NativeFormat;
 
 using InvokeTableFlags = Internal.Runtime.InvokeTableFlags;
-using FatFunctionPointerConstants = Internal.Runtime.FatFunctionPointerConstants;
 
 namespace ILCompiler.DependencyAnalysis
 {

src/ILCompiler.CppCodeGen/src/CppCodeGen/CppWriter.cs

@@ -17,7 +17,6 @@
 using Internal.TypeSystem.Ecma;
 
 using Debug = System.Diagnostics.Debug;
-using FatFunctionPointerConstants = Internal.Runtime.FatFunctionPointerConstants;
 
 namespace ILCompiler.CppCodeGen
 {
@@ -2102,7 +2101,7 @@ private string GetCodeForReadyToRunGenericHelper(ReadyToRunGenericHelperNode nod
                         sb.Append(" = ((intptr_t)");
                         sb.Append(resVarName);
                         sb.Append(") + ");
-                        sb.Append(FatFunctionPointerConstants.Offset.ToString());
+                        sb.Append(constructor.Context.Target.FatFunctionPointerOffset.ToString());
                         sb.Append(";");
                         sb.AppendLine();
 
@@ -2290,7 +2289,7 @@ private void OutputStaticsCode(NodeFactory factory, Dictionary<TypeDesc, CppGene
                             sb.Append("(char *)");
                             sb.Append(GetCppFatFunctionPointerNameForMethod(cctor));
                             sb.Append("() + ");
-                            sb.Append(FatFunctionPointerConstants.Offset.ToString());
+                            sb.Append(cctor.Context.Target.FatFunctionPointerOffset.ToString());
                         }
                         else
                         {

src/ILCompiler.CppCodeGen/src/CppCodeGen/ILToCppImporter.cs

@@ -14,8 +14,6 @@
 
 using ILCompiler.DependencyAnalysis;
 
-using FatFunctionPointerConstants = Internal.Runtime.FatFunctionPointerConstants;
-
 namespace Internal.IL
 {
     internal partial class ILImporter
@@ -1376,7 +1374,7 @@ private void ImportCall(ILOpcode opcode, int token)
                                 sb.Append("((intptr_t)");
                                 sb.Append(_writer.GetCppSymbolNodeName(_nodeFactory, targetNode));
                                 sb.Append("()) + ");
-                                sb.Append(FatFunctionPointerConstants.Offset.ToString());
+                                sb.Append(_typeSystemContext.Target.FatFunctionPointerOffset.ToString());
                             }
                             else
                             {
@@ -1518,13 +1516,13 @@ private void ImportCall(ILOpcode opcode, int token)
                 Append("if (");
                 Append(gvmSlotVarName);
                 Append(" & ");
-                Append(FatFunctionPointerConstants.Offset.ToString());
+                Append(_typeSystemContext.Target.FatFunctionPointerOffset.ToString());
                 Append(") {");
                 Append(functionPtr);
                 Append(" = *(intptr_t*)(");
                 Append(gvmSlotVarName);
                 Append(" - ");
-                Append(FatFunctionPointerConstants.Offset.ToString());
+                Append(_typeSystemContext.Target.FatFunctionPointerOffset.ToString());
                 Append(");} else {");
                 Append(functionPtr);
                 Append(" = ");
@@ -1725,7 +1723,7 @@ private void ImportCall(ILOpcode opcode, int token)
                 Append("if (");
                 Append(gvmSlotVarName);
                 Append(" & ");
-                Append(FatFunctionPointerConstants.Offset.ToString());
+                Append(_typeSystemContext.Target.FatFunctionPointerOffset.ToString());
                 Append(") {");
 
                 _writer.AppendSignatureTypeDef(_builder, typeDefName, canonMethodSignature,
@@ -1762,7 +1760,7 @@ private void ImportCall(ILOpcode opcode, int token)
                 Append("**(void***)(");
                 Append(gvmSlotVarName);
                 Append(" - ");
-                Append(FatFunctionPointerConstants.Offset.ToString());
+                Append(_typeSystemContext.Target.FatFunctionPointerOffset.ToString());
                 Append(" + sizeof(void*))");
 
                 if (canonMethodSignature.Length > 0)
@@ -2116,13 +2114,13 @@ private void ImportCalli(int token)
             Append("if (");
             Append(fatPtr);
             Append(" & ");
-            Append(FatFunctionPointerConstants.Offset.ToString());
+            Append(_typeSystemContext.Target.FatFunctionPointerOffset.ToString());
             Append(") {");
             Append(fnPtrValue);
             Append(" = *(intptr_t*)(");
             Append(fatPtr);
             Append(" - ");
-            Append(FatFunctionPointerConstants.Offset.ToString());
+            Append(_typeSystemContext.Target.FatFunctionPointerOffset.ToString());
             Append(")");
 
             AppendSemicolon();
@@ -2155,7 +2153,7 @@ private void ImportCalli(int token)
             Append("**(void***)(");
             Append(fatPtr);
             Append(" - ");
-            Append(FatFunctionPointerConstants.Offset.ToString());
+            Append(_typeSystemContext.Target.FatFunctionPointerOffset.ToString());
             Append(" + sizeof(void*))");
 
             if (methodSignature.Length > 0)
@@ -2309,14 +2307,14 @@ private void ImportLdFtn(int token, ILOpcode opCode)
                             Append("(");
                             Append(GetGenericContext());
                             Append(")) + ");
-                            Append(FatFunctionPointerConstants.Offset.ToString());
+                            Append(_typeSystemContext.Target.FatFunctionPointerOffset.ToString());
                         }
                         else
                         {
                             Append("((intptr_t)");
                             AppendFatFunctionPointer(runtimeDeterminedMethod);
                             Append("()) + ");
-                            Append(FatFunctionPointerConstants.Offset.ToString());
+                            Append(_typeSystemContext.Target.FatFunctionPointerOffset.ToString());
                         }
                     }
                     else

src/ILCompiler.TypeSystem/src/ILCompiler.TypeSystem.csproj

@@ -79,6 +79,9 @@
     <Compile Include="..\..\Common\src\TypeSystem\Canon\TypeSystemContext.Canon.cs">
       <Link>TypeSystem\Canon\TypeSystemContext.Canon.cs</Link>
     </Compile>
+    <Compile Include="..\..\Common\src\TypeSystem\Aot\TargetDetails.Aot.cs">
+      <Link>TypeSystem\Aot\TargetDetails.Aot.cs</Link>
+    </Compile>
     <Compile Include="..\..\Common\src\TypeSystem\CodeGen\FieldDesc.CodeGen.cs">
       <Link>TypeSystem\CodeGen\FieldDesc.CodeGen.cs</Link>
     </Compile>

src/ILCompiler.WebAssembly/src/CodeGen/EvaluationStack.cs

@@ -403,6 +403,20 @@ public override StackEntry Duplicate(LLVMBuilderRef builder)
         }
     }
 
+    /// <summary>
+    /// Entry representing the generic return value of a function.
+    /// </summary>
+    internal class GenericReturnExpressionEntry : ExpressionEntry
+    {
+        public GenericReturnExpressionEntry(TypeDesc genericReturnTypeDesc, StackValueKind kind, string name, LLVMValueRef llvmValue, TypeDesc type = null) 
+            : base(kind, name, llvmValue, type)
+        {
+            GenericReturnTypeDesc = genericReturnTypeDesc;
+        }
+
+        public TypeDesc GenericReturnTypeDesc { get; }
+    }
+
     /// <summary>
     /// Entry representing some expression
     /// </summary>