BitOperations are now used for native performance of certain WASM instructions when the target framework supports it.

RyanLamansky · RyanLamansky · commit ecd849908573 · 2022-07-30T10:27:36.000-05:00
diff --git a/WebAssembly/Instructions/Int32CountLeadingZeroes.cs b/WebAssembly/Instructions/Int32CountLeadingZeroes.cs
@@ -1,4 +1,8 @@
-﻿using System.Reflection.Emit;
+﻿#if NETCOREAPP3_0_OR_GREATER
+using System.Numerics;
+using System.Reflection;
+#endif
+using System.Reflection.Emit;
 using WebAssembly.Runtime.Compilation;
 
 namespace WebAssembly.Instructions;
@@ -20,11 +24,18 @@ public Int32CountLeadingZeroes()
     {
     }
 
+#if NETCOREAPP3_0_OR_GREATER
+    private static readonly MethodInfo leadingZeroCount = typeof(BitOperations).GetMethod(nameof(BitOperations.LeadingZeroCount), new[] { typeof(uint) })!;
+#endif
+
     internal sealed override void Compile(CompilationContext context)
     {
         //Assuming validation passes, the remaining type will be Int32.
         context.ValidateStack(OpCode.Int32CountLeadingZeroes, WebAssemblyValueType.Int32);
 
+#if NETCOREAPP3_0_OR_GREATER
+        context.Emit(OpCodes.Call, leadingZeroCount);
+#else
         context.Emit(OpCodes.Call, context[HelperMethod.Int32CountLeadingZeroes, (helper, c) =>
         {
             var result = context.CheckedExportsBuilder.DefineMethod(
@@ -80,6 +91,7 @@ internal sealed override void Compile(CompilationContext context)
 
             return result;
         }
-        ]);
+        ]);  
+#endif
     }
 }
diff --git a/WebAssembly/Instructions/Int32CountOneBits.cs b/WebAssembly/Instructions/Int32CountOneBits.cs
@@ -1,4 +1,8 @@
-﻿using System.Reflection.Emit;
+﻿#if NETCOREAPP3_0_OR_GREATER
+using System.Numerics;
+using System.Reflection;
+#endif
+using System.Reflection.Emit;
 using WebAssembly.Runtime.Compilation;
 
 namespace WebAssembly.Instructions;
@@ -20,11 +24,18 @@ public Int32CountOneBits()
     {
     }
 
+#if NETCOREAPP3_0_OR_GREATER
+    private static readonly MethodInfo popCount = typeof(BitOperations).GetMethod(nameof(BitOperations.PopCount), new[] { typeof(uint) })!;
+#endif
+
     internal sealed override void Compile(CompilationContext context)
     {
         //Assuming validation passes, the remaining type will be Int32.
         context.ValidateStack(OpCode.Int32CountOneBits, WebAssemblyValueType.Int32);
 
+#if NETCOREAPP3_0_OR_GREATER
+        context.Emit(OpCodes.Call, popCount);
+#else
         context.Emit(OpCodes.Call, context[HelperMethod.Int32CountOneBits, CreateHelper]);
     }
 
@@ -71,7 +82,7 @@ internal static MethodBuilder CreateHelper(HelperMethod helper, CompilationConte
         il.Emit(OpCodes.Ldc_I4_S, 24);
         il.Emit(OpCodes.Shr_Un);
         il.Emit(OpCodes.Ret);
-
         return result;
+#endif
     }
 }
diff --git a/WebAssembly/Instructions/Int32CountTrailingZeroes.cs b/WebAssembly/Instructions/Int32CountTrailingZeroes.cs
@@ -1,4 +1,8 @@
-﻿using System.Reflection.Emit;
+﻿#if NETCOREAPP3_0_OR_GREATER
+using System.Numerics;
+using System.Reflection;
+#endif
+using System.Reflection.Emit;
 using WebAssembly.Runtime.Compilation;
 
 namespace WebAssembly.Instructions;
@@ -20,11 +24,18 @@ public Int32CountTrailingZeroes()
     {
     }
 
+#if NETCOREAPP3_0_OR_GREATER
+    private static readonly MethodInfo trailingZeroCount = typeof(BitOperations).GetMethod(nameof(BitOperations.TrailingZeroCount), new[] { typeof(uint) })!;
+#endif
+
     internal sealed override void Compile(CompilationContext context)
     {
         //Assuming validation passes, the remaining type will be this.
         context.ValidateStack(OpCode.Int32CountTrailingZeroes, WebAssemblyValueType.Int32);
 
+#if NETCOREAPP3_0_OR_GREATER
+        context.Emit(OpCodes.Call, trailingZeroCount);
+#else
         context.Emit(OpCodes.Call, context[HelperMethod.Int32CountTrailingZeroes, (helper, c) =>
         {
             var result = context.CheckedExportsBuilder.DefineMethod(
@@ -49,5 +60,6 @@ internal sealed override void Compile(CompilationContext context)
             return result;
         }
         ]);
+#endif
     }
 }
diff --git a/WebAssembly/Instructions/Int32RotateLeft.cs b/WebAssembly/Instructions/Int32RotateLeft.cs
@@ -1,4 +1,8 @@
-﻿using System.Reflection.Emit;
+﻿#if NETCOREAPP3_0_OR_GREATER
+using System.Numerics;
+using System.Reflection;
+#endif
+using System.Reflection.Emit;
 using WebAssembly.Runtime.Compilation;
 
 namespace WebAssembly.Instructions;
@@ -20,13 +24,20 @@ public Int32RotateLeft()
     {
     }
 
+#if NETCOREAPP3_0_OR_GREATER
+    private static readonly MethodInfo rotateLeft = typeof(BitOperations).GetMethod(nameof(BitOperations.RotateLeft), new[] { typeof(uint), typeof(int) })!;
+#endif
+
     internal sealed override void Compile(CompilationContext context)
     {
         var stack = context.Stack;
 
         context.PopStackNoReturn(OpCode.Int32RotateLeft, WebAssemblyValueType.Int32, WebAssemblyValueType.Int32);
         stack.Push(WebAssemblyValueType.Int32);
 
+#if NETCOREAPP3_0_OR_GREATER
+        context.Emit(OpCodes.Call, rotateLeft);
+#else
         context.Emit(OpCodes.Call, context[HelperMethod.Int32RotateLeft, (helper, c) =>
         {
             var builder = c.CheckedExportsBuilder.DefineMethod(
@@ -60,5 +71,6 @@ internal sealed override void Compile(CompilationContext context)
             return builder;
         }
         ]);
+#endif
     }
 }
diff --git a/WebAssembly/Instructions/Int32RotateRight.cs b/WebAssembly/Instructions/Int32RotateRight.cs
@@ -1,4 +1,8 @@
-﻿using System.Reflection.Emit;
+﻿#if NETCOREAPP3_0_OR_GREATER
+using System.Numerics;
+using System.Reflection;
+#endif
+using System.Reflection.Emit;
 using WebAssembly.Runtime.Compilation;
 
 namespace WebAssembly.Instructions;
@@ -20,13 +24,20 @@ public Int32RotateRight()
     {
     }
 
+#if NETCOREAPP3_0_OR_GREATER
+    private static readonly MethodInfo rotateRight = typeof(BitOperations).GetMethod(nameof(BitOperations.RotateRight), new[] { typeof(uint), typeof(int) })!;
+#endif
+
     internal sealed override void Compile(CompilationContext context)
     {
         var stack = context.Stack;
 
         context.PopStackNoReturn(OpCode.Int32RotateRight, WebAssemblyValueType.Int32, WebAssemblyValueType.Int32);
         stack.Push(WebAssemblyValueType.Int32);
 
+#if NETCOREAPP3_0_OR_GREATER
+        context.Emit(OpCodes.Call, rotateRight);
+#else
         context.Emit(OpCodes.Call, context[HelperMethod.Int32RotateRight, (helper, c) =>
         {
             var builder = c.CheckedExportsBuilder.DefineMethod(
@@ -60,5 +71,6 @@ internal sealed override void Compile(CompilationContext context)
             return builder;
         }
         ]);
+#endif
     }
 }
diff --git a/WebAssembly/Instructions/Int64CountLeadingZeroes.cs b/WebAssembly/Instructions/Int64CountLeadingZeroes.cs
@@ -1,4 +1,8 @@
-﻿using System.Reflection.Emit;
+﻿#if NETCOREAPP3_0_OR_GREATER
+using System.Numerics;
+using System.Reflection;
+#endif
+using System.Reflection.Emit;
 using WebAssembly.Runtime.Compilation;
 
 namespace WebAssembly.Instructions;
@@ -20,11 +24,18 @@ public Int64CountLeadingZeroes()
     {
     }
 
+#if NETCOREAPP3_0_OR_GREATER
+    private static readonly MethodInfo leadingZeroCount = typeof(BitOperations).GetMethod(nameof(BitOperations.LeadingZeroCount), new[] { typeof(ulong) })!;
+#endif
+
     internal sealed override void Compile(CompilationContext context)
     {
         //Assuming validation passes, the remaining type will be Int64.
         context.ValidateStack(OpCode.Int64CountLeadingZeroes, WebAssemblyValueType.Int64);
 
+#if NETCOREAPP3_0_OR_GREATER
+        context.Emit(OpCodes.Call, leadingZeroCount);
+#else
         context.Emit(OpCodes.Call, context[HelperMethod.Int64CountLeadingZeroes, (helper, c) =>
         {
             var result = context.CheckedExportsBuilder.DefineMethod(
@@ -89,5 +100,6 @@ internal sealed override void Compile(CompilationContext context)
             return result;
         }
         ]);
+#endif
     }
 }
diff --git a/WebAssembly/Instructions/Int64CountOneBits.cs b/WebAssembly/Instructions/Int64CountOneBits.cs
@@ -1,4 +1,8 @@
-﻿using System.Reflection.Emit;
+﻿#if NETCOREAPP3_0_OR_GREATER
+using System.Numerics;
+using System.Reflection;
+#endif
+using System.Reflection.Emit;
 using WebAssembly.Runtime.Compilation;
 
 namespace WebAssembly.Instructions;
@@ -20,11 +24,18 @@ public Int64CountOneBits()
     {
     }
 
+#if NETCOREAPP3_0_OR_GREATER
+    private static readonly MethodInfo popCount = typeof(BitOperations).GetMethod(nameof(BitOperations.PopCount), new[] { typeof(ulong) })!;
+#endif
+
     internal sealed override void Compile(CompilationContext context)
     {
         //Assuming validation passes, the remaining type will be Int64.
         context.ValidateStack(OpCode.Int64CountOneBits, WebAssemblyValueType.Int64);
 
+#if NETCOREAPP3_0_OR_GREATER
+        context.Emit(OpCodes.Call, popCount);
+#else
         context.Emit(OpCodes.Call, context[HelperMethod.Int64CountOneBits, CreateHelper]);
     }
 
@@ -73,5 +84,6 @@ internal static MethodBuilder CreateHelper(HelperMethod helper, CompilationConte
         il.Emit(OpCodes.Ret);
 
         return result;
+#endif
     }
 }
diff --git a/WebAssembly/Instructions/Int64CountTrailingZeroes.cs b/WebAssembly/Instructions/Int64CountTrailingZeroes.cs
@@ -1,4 +1,8 @@
-﻿using System.Reflection.Emit;
+﻿#if NETCOREAPP3_0_OR_GREATER
+using System.Numerics;
+using System.Reflection;
+#endif
+using System.Reflection.Emit;
 using WebAssembly.Runtime.Compilation;
 
 namespace WebAssembly.Instructions;
@@ -20,11 +24,18 @@ public Int64CountTrailingZeroes()
     {
     }
 
+#if NETCOREAPP3_0_OR_GREATER
+    private static readonly MethodInfo trailingZeroCount = typeof(BitOperations).GetMethod(nameof(BitOperations.TrailingZeroCount), new[] { typeof(ulong) })!;
+#endif
+
     internal sealed override void Compile(CompilationContext context)
     {
         //Assuming validation passes, the remaining type will be Int64.
         context.ValidateStack(OpCode.Int64CountTrailingZeroes, WebAssemblyValueType.Int64);
 
+#if NETCOREAPP3_0_OR_GREATER
+        context.Emit(OpCodes.Call, trailingZeroCount);
+#else
         context.Emit(OpCodes.Call, context[HelperMethod.Int64CountTrailingZeroes, (helper, c) =>
         {
             var result = context.CheckedExportsBuilder.DefineMethod(
@@ -50,5 +61,6 @@ internal sealed override void Compile(CompilationContext context)
             return result;
         }
         ]);
+#endif
     }
 }
diff --git a/WebAssembly/Instructions/Int64RotateLeft.cs b/WebAssembly/Instructions/Int64RotateLeft.cs
@@ -1,4 +1,8 @@
-﻿using System.Reflection.Emit;
+﻿#if NETCOREAPP3_0_OR_GREATER
+using System.Numerics;
+using System.Reflection;
+#endif
+using System.Reflection.Emit;
 using WebAssembly.Runtime.Compilation;
 
 namespace WebAssembly.Instructions;
@@ -20,13 +24,21 @@ public Int64RotateLeft()
     {
     }
 
+#if NETCOREAPP3_0_OR_GREATER
+    private static readonly MethodInfo rotateLeft = typeof(BitOperations).GetMethod(nameof(BitOperations.RotateLeft), new[] { typeof(ulong), typeof(int) })!;
+#endif
+
     internal sealed override void Compile(CompilationContext context)
     {
         var stack = context.Stack;
 
         context.PopStackNoReturn(OpCode.Int64RotateLeft, WebAssemblyValueType.Int64, WebAssemblyValueType.Int64);
         stack.Push(WebAssemblyValueType.Int64);
 
+#if NETCOREAPP3_0_OR_GREATER
+        context.Emit(OpCodes.Conv_I4);
+        context.Emit(OpCodes.Call, rotateLeft);
+#else
         context.Emit(OpCodes.Call, context[HelperMethod.Int64RotateLeft, (helper, c) =>
         {
             var builder = c.CheckedExportsBuilder.DefineMethod(
@@ -62,5 +74,6 @@ internal sealed override void Compile(CompilationContext context)
             return builder;
         }
         ]);
+#endif
     }
 }
diff --git a/WebAssembly/Instructions/Int64RotateRight.cs b/WebAssembly/Instructions/Int64RotateRight.cs
@@ -1,4 +1,8 @@
-﻿using System.Reflection.Emit;
+﻿#if NETCOREAPP3_0_OR_GREATER
+using System.Numerics;
+using System.Reflection;
+#endif
+using System.Reflection.Emit;
 using WebAssembly.Runtime.Compilation;
 
 namespace WebAssembly.Instructions;
@@ -20,13 +24,21 @@ public Int64RotateRight()
     {
     }
 
+#if NETCOREAPP3_0_OR_GREATER
+    private static readonly MethodInfo rotateRight = typeof(BitOperations).GetMethod(nameof(BitOperations.RotateRight), new[] { typeof(ulong), typeof(int) })!;
+#endif
+
     internal sealed override void Compile(CompilationContext context)
     {
         var stack = context.Stack;
 
         context.PopStackNoReturn(OpCode.Int64RotateRight, WebAssemblyValueType.Int64, WebAssemblyValueType.Int64);
         stack.Push(WebAssemblyValueType.Int64);
 
+#if NETCOREAPP3_0_OR_GREATER
+        context.Emit(OpCodes.Conv_I4);
+        context.Emit(OpCodes.Call, rotateRight);
+#else
         context.Emit(OpCodes.Call, context[HelperMethod.Int64RotateRight, (helper, c) =>
         {
             var builder = c.CheckedExportsBuilder.DefineMethod(
@@ -62,5 +74,6 @@ internal sealed override void Compile(CompilationContext context)
             return builder;
         }
         ]);
+#endif
     }
 }
diff --git a/WebAssembly/Runtime/Compilation/HelperMethod.cs b/WebAssembly/Runtime/Compilation/HelperMethod.cs
@@ -26,6 +26,7 @@ enum HelperMethod
     Float32CopySign,
     Float64CopySign,
     GrowMemory,
+#if !NETCOREAPP3_0_OR_GREATER
     Int32CountOneBits,
     Int64CountOneBits,
     Int32CountLeadingZeroes,
@@ -36,6 +37,7 @@ enum HelperMethod
     Int32RotateRight,
     Int64RotateLeft,
     Int64RotateRight,
+#endif
     Int32TruncateSaturateFloat32Signed,
     Int32TruncateSaturateFloat32Unsigned,
     Int32TruncateSaturateFloat64Signed,

Original file line number	Diff line number	Diff line change
`@@ -1,4 +1,8 @@`
`1`		`-using System.Reflection.Emit;`
	`1`	`+#if NETCOREAPP3_0_OR_GREATER`
	`2`	`+using System.Numerics;`
	`3`	`+using System.Reflection;`
	`4`	`+#endif`
	`5`	`+using System.Reflection.Emit;`
`2`	`6`	`using WebAssembly.Runtime.Compilation;`
`3`	`7`
`4`	`8`	`namespace WebAssembly.Instructions;`
`@@ -20,11 +24,18 @@ public Int32CountLeadingZeroes()`
`20`	`24`	`{`
`21`	`25`	`}`
`22`	`26`
	`27`	`+#if NETCOREAPP3_0_OR_GREATER`
	`28`	`+ private static readonly MethodInfo leadingZeroCount = typeof(BitOperations).GetMethod(nameof(BitOperations.LeadingZeroCount), new[] { typeof(uint) })!;`
	`29`	`+#endif`
	`30`	`+`
`23`	`31`	`internal sealed override void Compile(CompilationContext context)`
`24`	`32`	`{`
`25`	`33`	`//Assuming validation passes, the remaining type will be Int32.`
`26`	`34`	`context.ValidateStack(OpCode.Int32CountLeadingZeroes, WebAssemblyValueType.Int32);`
`27`	`35`
	`36`	`+#if NETCOREAPP3_0_OR_GREATER`
	`37`	`+ context.Emit(OpCodes.Call, leadingZeroCount);`
	`38`	`+#else`
`28`	`39`	`context.Emit(OpCodes.Call, context[HelperMethod.Int32CountLeadingZeroes, (helper, c) =>`
`29`	`40`	`{`
`30`	`41`	`var result = context.CheckedExportsBuilder.DefineMethod(`
`@@ -80,6 +91,7 @@ internal sealed override void Compile(CompilationContext context)`
`80`	`91`
`81`	`92`	`return result;`
`82`	`93`	`}`
`83`		`- ]);`
	`94`	`+ ]);`
	`95`	`+#endif`
`84`	`96`	`}`
`85`	`97`	`}`