From: dotnet-maestro[bot] <42748379+dotnet-maestro[bot]@users.noreply.github.com>
Date: Sat, 9 Nov 2019 20:33:43 +0000 (+0000)
Subject: [master] Update dependencies from dotnet/coreclr (dotnet/corefx#42443)
X-Git-Tag: submit/tizen/20210909.063632~11031^2~45
X-Git-Url: http://review.tizen.org/git/?a=commitdiff_plain;h=608418d496527412c06bd3f211cccf693445e014;p=platform%2Fupstream%2Fdotnet%2Fruntime.git

[master] Update dependencies from dotnet/coreclr (dotnet/corefx#42443)

* Arm64: Update reference assembly for ReverseBitOrder

* Arm64: Update reference assembly for AddAcross

* Add UnzipEven & UnzipOdd

* Add Ziplow & ZipHigh

* Expose and test MemoryExtensions.Sort

* Improve diagnostics from failing SendRecvIovMaxTcp_Success test

* Update dependencies from https://github.com/dotnet/coreclr build 20191109.4


Commit migrated from https://github.com/dotnet/corefx/commit/2e513ecac65f5a3fa9433df6f267544435914611
---

diff --git a/src/libraries/System.Memory/ref/System.Memory.cs b/src/libraries/System.Memory/ref/System.Memory.cs
index bd1cc07..8ce1a84 100644
--- a/src/libraries/System.Memory/ref/System.Memory.cs
+++ b/src/libraries/System.Memory/ref/System.Memory.cs
@@ -163,6 +163,12 @@ namespace System
 #nullable disable
             where T : System.IEquatable<T> { throw null; }
 #nullable restore
+        public static void Sort<T>(this System.Span<T> span) { }
+        public static void Sort<T, TComparer>(this System.Span<T> span, TComparer comparer) where TComparer : System.Collections.Generic.IComparer<T>? { }
+        public static void Sort<T>(this System.Span<T> span, System.Comparison<T> comparison) { }
+        public static void Sort<TKey, TValue>(this System.Span<TKey> keys, System.Span<TValue> items) { }
+        public static void Sort<TKey, TValue, TComparer>(this System.Span<TKey> keys, System.Span<TValue> items, TComparer comparer) where TComparer : System.Collections.Generic.IComparer<TKey>? { }
+        public static void Sort<TKey, TValue>(this System.Span<TKey> keys, System.Span<TValue> items, System.Comparison<TKey> comparison) { }
         public static bool StartsWith(this System.ReadOnlySpan<char> span, System.ReadOnlySpan<char> value, System.StringComparison comparisonType) { throw null; }
         public static bool StartsWith<T>(this System.ReadOnlySpan<T> span, System.ReadOnlySpan<T> value)
 #nullable disable
diff --git a/src/libraries/System.Memory/tests/Span/Sort.cs b/src/libraries/System.Memory/tests/Span/Sort.cs
new file mode 100644
index 0000000..357cbf6
--- /dev/null
+++ b/src/libraries/System.Memory/tests/Span/Sort.cs
@@ -0,0 +1,148 @@
+// 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.
+
+using System.Collections.Generic;
+using System.Linq;
+using Xunit;
+
+namespace System.SpanTests
+{
+    public static partial class SpanTests
+    {
+        [Fact]
+        public static void Sort_InvalidArguments_Throws()
+        {
+            AssertExtensions.Throws<ArgumentNullException>("comparison", () => MemoryExtensions.Sort(Span<byte>.Empty, (Comparison<byte>)null));
+            AssertExtensions.Throws<ArgumentNullException>("comparison", () => MemoryExtensions.Sort(Span<byte>.Empty, Span<byte>.Empty, (Comparison<byte>)null));
+
+            Assert.Throws<ArgumentException>(() => MemoryExtensions.Sort((Span<byte>)new byte[1], (Span<byte>)new byte[2]));
+            Assert.Throws<ArgumentException>(() => MemoryExtensions.Sort((Span<byte>)new byte[2], (Span<byte>)new byte[1]));
+            Assert.Throws<ArgumentException>(() => MemoryExtensions.Sort((Span<byte>)new byte[1], (Span<byte>)new byte[2], Comparer<byte>.Default.Compare));
+            Assert.Throws<ArgumentException>(() => MemoryExtensions.Sort((Span<byte>)new byte[2], (Span<byte>)new byte[1], Comparer<byte>.Default.Compare));
+            Assert.Throws<ArgumentException>(() => MemoryExtensions.Sort((Span<byte>)new byte[1], (Span<byte>)new byte[2], Comparer<byte>.Default));
+            Assert.Throws<ArgumentException>(() => MemoryExtensions.Sort((Span<byte>)new byte[2], (Span<byte>)new byte[1], Comparer<byte>.Default));
+
+            Assert.Throws<InvalidOperationException>(() => MemoryExtensions.Sort((Span<NotImcomparable>)new NotImcomparable[10]));
+            Assert.Throws<InvalidOperationException>(() => MemoryExtensions.Sort((Span<NotImcomparable>)new NotImcomparable[10], (Span<byte>)new byte[10]));
+        }
+
+        private struct NotImcomparable { }
+
+        [Theory]
+        [InlineData(0)]
+        [InlineData(1)]
+        [InlineData(2)]
+        [InlineData(3)]
+        [InlineData(4)]
+        [InlineData(5)]
+        public static void Sort_CovariantArraysAllowed(int overload)
+        {
+            Span<object> actual = Enumerable.Range(0, 10).Select(i => (object)i.ToString()).Reverse().ToArray();
+
+            object[] expected = actual.ToArray();
+            Array.Sort(expected);
+
+            switch (overload)
+            {
+                case 0:
+                    MemoryExtensions.Sort(actual);
+                    break;
+                case 1:
+                    MemoryExtensions.Sort(actual, StringComparer.CurrentCulture.Compare);
+                    break;
+                case 2:
+                    MemoryExtensions.Sort(actual, (IComparer<object>)null);
+                    break;
+                case 3:
+                    MemoryExtensions.Sort(actual, new byte[actual.Length].AsSpan());
+                    break;
+                case 4:
+                    MemoryExtensions.Sort(actual, new byte[actual.Length].AsSpan(), StringComparer.CurrentCulture.Compare);
+                    break;
+                case 5:
+                    MemoryExtensions.Sort(actual, new byte[actual.Length].AsSpan(), (IComparer<object>)null);
+                    break;
+            }
+
+            Assert.Equal(expected, actual.ToArray());
+        }
+
+        [Theory]
+        [MemberData(nameof(Sort_MemberData))]
+        public static void Sort<T>(T[] origKeys, IComparer<T> comparer)
+        {
+            T[] expectedKeys = origKeys.ToArray();
+            Array.Sort(expectedKeys, comparer);
+
+            byte[] origValues = new byte[origKeys.Length];
+            new Random(42).NextBytes(origValues);
+            byte[] expectedValues = origValues.ToArray();
+            Array.Sort(origKeys.ToArray(), expectedValues, comparer);
+
+            Span<T> keys;
+            Span<byte> values;
+
+            if (comparer == null)
+            {
+                keys = origKeys.ToArray();
+                MemoryExtensions.Sort(keys);
+                Assert.Equal(expectedKeys, keys.ToArray());
+            }
+
+            keys = origKeys.ToArray();
+            MemoryExtensions.Sort(keys, comparer);
+            Assert.Equal(expectedKeys, keys.ToArray());
+
+            keys = origKeys.ToArray();
+            MemoryExtensions.Sort(keys, comparer != null ? (Comparison<T>)comparer.Compare : Comparer<T>.Default.Compare);
+            Assert.Equal(expectedKeys, keys.ToArray());
+
+            if (comparer == null)
+            {
+                keys = origKeys.ToArray();
+                values = origValues.ToArray();
+                MemoryExtensions.Sort(keys, values);
+                Assert.Equal(expectedKeys, keys.ToArray());
+                Assert.Equal(expectedValues, values.ToArray());
+            }
+
+            keys = origKeys.ToArray();
+            values = origValues.ToArray();
+            MemoryExtensions.Sort(keys, values, comparer);
+            Assert.Equal(expectedKeys, keys.ToArray());
+            Assert.Equal(expectedValues, values.ToArray());
+
+            keys = origKeys.ToArray();
+            values = origValues.ToArray();
+            MemoryExtensions.Sort(keys, values, comparer != null ? (Comparison<T>)comparer.Compare : Comparer<T>.Default.Compare);
+            Assert.Equal(expectedKeys, keys.ToArray());
+            Assert.Equal(expectedValues, values.ToArray());
+        }
+
+        public static IEnumerable<object[]> Sort_MemberData()
+        {
+            var rand = new Random(42);
+            foreach (int length in new[] { 0, 1, 2, 3, 10 })
+            {
+                yield return new object[] { CreateArray(i => i.ToString()), null };
+                yield return new object[] { CreateArray(i => (byte)i), null };
+                yield return new object[] { CreateArray(i => (sbyte)i), null };
+                yield return new object[] { CreateArray(i => (ushort)i), null };
+                yield return new object[] { CreateArray(i => (short)i), null };
+                yield return new object[] { CreateArray(i => (uint)i), null };
+                yield return new object[] { CreateArray(i => i), null };
+                yield return new object[] { CreateArray(i => (ulong)i), null };
+                yield return new object[] { CreateArray(i => (long)i), null };
+                yield return new object[] { CreateArray(i => (char)i), null };
+                yield return new object[] { CreateArray(i => i % 2 == 0), null };
+                yield return new object[] { CreateArray(i => (float)i), null };
+                yield return new object[] { CreateArray(i => (double)i), null };
+                yield return new object[] { CreateArray(i => (IntPtr)i), Comparer<IntPtr>.Create((i, j) => i.ToInt64().CompareTo(j.ToInt64())) };
+                yield return new object[] { CreateArray(i => (UIntPtr)i), Comparer<UIntPtr>.Create((i, j) => i.ToUInt64().CompareTo(j.ToUInt64())) };
+
+                T[] CreateArray<T>(Func<int, T> getValue) => Enumerable.Range(0, length).Select(_ => getValue(rand.Next())).ToArray();
+            }
+        }
+    }
+}
diff --git a/src/libraries/System.Memory/tests/System.Memory.Tests.csproj b/src/libraries/System.Memory/tests/System.Memory.Tests.csproj
index f611c60..cd8c48e 100644
--- a/src/libraries/System.Memory/tests/System.Memory.Tests.csproj
+++ b/src/libraries/System.Memory/tests/System.Memory.Tests.csproj
@@ -100,6 +100,7 @@
     <Compile Include="Span\SequenceEqual.long.cs" />
     <Compile Include="Span\SequenceEqual.T.cs" />
     <Compile Include="Span\Slice.cs" />
+    <Compile Include="Span\Sort.cs" />
     <Compile Include="Span\StartsWith.byte.cs" />
     <Compile Include="Span\StartsWith.char.cs" />
     <Compile Include="Span\StartsWith.long.cs" />
diff --git a/src/libraries/System.Net.Sockets/tests/FunctionalTests/SendReceive.cs b/src/libraries/System.Net.Sockets/tests/FunctionalTests/SendReceive.cs
index a679a1b..3f39b82 100644
--- a/src/libraries/System.Net.Sockets/tests/FunctionalTests/SendReceive.cs
+++ b/src/libraries/System.Net.Sockets/tests/FunctionalTests/SendReceive.cs
@@ -1207,7 +1207,7 @@ namespace System.Net.Sockets.Tests
                         Assert.Equal(SocketError.Success, error);
                     } while (bytesReceivedTotal != SegmentCount);
 
-                    Assert.Equal(sendBuffer, receiveBuffer);
+                    AssertExtensions.Equal(sendBuffer, receiveBuffer);
                 }
             }
         }
diff --git a/src/libraries/System.Runtime.Intrinsics.Experimental/ref/System.Runtime.Intrinsics.Experimental.cs b/src/libraries/System.Runtime.Intrinsics.Experimental/ref/System.Runtime.Intrinsics.Experimental.cs
index 2578bec..61005ee 100644
--- a/src/libraries/System.Runtime.Intrinsics.Experimental/ref/System.Runtime.Intrinsics.Experimental.cs
+++ b/src/libraries/System.Runtime.Intrinsics.Experimental/ref/System.Runtime.Intrinsics.Experimental.cs
@@ -220,7 +220,89 @@ namespace System.Runtime.Intrinsics.Arm
             public static System.Runtime.Intrinsics.Vector128<double> Abs(System.Runtime.Intrinsics.Vector128<double> value) { throw null; }
             public static System.Runtime.Intrinsics.Vector128<ulong> Abs(System.Runtime.Intrinsics.Vector128<long> value) { throw null; }
             public static System.Runtime.Intrinsics.Vector128<double> Add(System.Runtime.Intrinsics.Vector128<double> left, System.Runtime.Intrinsics.Vector128<double> right) { throw null; }
+            public static byte AddAcross(System.Runtime.Intrinsics.Vector64<byte> value) { throw null; }
+            public static short AddAcross(System.Runtime.Intrinsics.Vector64<short> value) { throw null; }
+            public static sbyte AddAcross(System.Runtime.Intrinsics.Vector64<sbyte> value) { throw null; }
+            public static ushort AddAcross(System.Runtime.Intrinsics.Vector64<ushort> value) { throw null; }
+            public static byte AddAcross(System.Runtime.Intrinsics.Vector128<byte> value) { throw null; }
+            public static short AddAcross(System.Runtime.Intrinsics.Vector128<short> value) { throw null; }
+            public static int AddAcross(System.Runtime.Intrinsics.Vector128<int> value) { throw null; }
+            public static sbyte AddAcross(System.Runtime.Intrinsics.Vector128<sbyte> value) { throw null; }
+            public static ushort AddAcross(System.Runtime.Intrinsics.Vector128<ushort> value) { throw null; }
+            public static uint AddAcross(System.Runtime.Intrinsics.Vector128<uint> value) { throw null; }
             public static System.Runtime.Intrinsics.Vector128<double> Subtract(System.Runtime.Intrinsics.Vector128<double> left, System.Runtime.Intrinsics.Vector128<double> right) { throw null; }
+            public static System.Runtime.Intrinsics.Vector64<byte> ReverseElementBits(System.Runtime.Intrinsics.Vector64<byte> value) { throw null; }
+            public static System.Runtime.Intrinsics.Vector64<sbyte> ReverseElementBits(System.Runtime.Intrinsics.Vector64<sbyte> value)  { throw null; }
+            public static System.Runtime.Intrinsics.Vector128<byte> ReverseElementBits(System.Runtime.Intrinsics.Vector128<byte> value) { throw null; }
+            public static System.Runtime.Intrinsics.Vector128<sbyte> ReverseElementBits(System.Runtime.Intrinsics.Vector128<sbyte> value) { throw null; }
+            public static System.Runtime.Intrinsics.Vector64<byte> UnzipEven (System.Runtime.Intrinsics.Vector64<byte> left, System.Runtime.Intrinsics.Vector64<byte> right) { throw null; }
+            public static System.Runtime.Intrinsics.Vector64<short> UnzipEven (System.Runtime.Intrinsics.Vector64<short> left, System.Runtime.Intrinsics.Vector64<short> right) { throw null; }
+            public static System.Runtime.Intrinsics.Vector64<int> UnzipEven (System.Runtime.Intrinsics.Vector64<int> left, System.Runtime.Intrinsics.Vector64<int> right) { throw null; }
+            public static System.Runtime.Intrinsics.Vector64<sbyte> UnzipEven (System.Runtime.Intrinsics.Vector64<sbyte> left, System.Runtime.Intrinsics.Vector64<sbyte> right) { throw null; }
+            public static System.Runtime.Intrinsics.Vector64<float> UnzipEven (System.Runtime.Intrinsics.Vector64<float> left, System.Runtime.Intrinsics.Vector64<float> right) { throw null; }
+            public static System.Runtime.Intrinsics.Vector64<ushort> UnzipEven (System.Runtime.Intrinsics.Vector64<ushort> left, System.Runtime.Intrinsics.Vector64<ushort> right) { throw null; }
+            public static System.Runtime.Intrinsics.Vector64<uint> UnzipEven (System.Runtime.Intrinsics.Vector64<uint> left, System.Runtime.Intrinsics.Vector64<uint> right) { throw null; }
+            public static System.Runtime.Intrinsics.Vector128<byte> UnzipEven (System.Runtime.Intrinsics.Vector128<byte> left, System.Runtime.Intrinsics.Vector128<byte> right) { throw null; }
+            public static System.Runtime.Intrinsics.Vector128<double> UnzipEven (System.Runtime.Intrinsics.Vector128<double> left, System.Runtime.Intrinsics.Vector128<double> right) { throw null; }
+            public static System.Runtime.Intrinsics.Vector128<short> UnzipEven (System.Runtime.Intrinsics.Vector128<short> left, System.Runtime.Intrinsics.Vector128<short> right) { throw null; }
+            public static System.Runtime.Intrinsics.Vector128<int> UnzipEven (System.Runtime.Intrinsics.Vector128<int> left, System.Runtime.Intrinsics.Vector128<int> right) { throw null; }
+            public static System.Runtime.Intrinsics.Vector128<long> UnzipEven (System.Runtime.Intrinsics.Vector128<long> left, System.Runtime.Intrinsics.Vector128<long> right) { throw null; }
+            public static System.Runtime.Intrinsics.Vector128<sbyte> UnzipEven (System.Runtime.Intrinsics.Vector128<sbyte> left, System.Runtime.Intrinsics.Vector128<sbyte> right) { throw null; }
+            public static System.Runtime.Intrinsics.Vector128<float> UnzipEven (System.Runtime.Intrinsics.Vector128<float> left, System.Runtime.Intrinsics.Vector128<float> right) { throw null; }
+            public static System.Runtime.Intrinsics.Vector128<ushort> UnzipEven (System.Runtime.Intrinsics.Vector128<ushort> left, System.Runtime.Intrinsics.Vector128<ushort> right) { throw null; }
+            public static System.Runtime.Intrinsics.Vector128<uint> UnzipEven (System.Runtime.Intrinsics.Vector128<uint> left, System.Runtime.Intrinsics.Vector128<uint> right) { throw null; }
+            public static System.Runtime.Intrinsics.Vector128<ulong> UnzipEven (System.Runtime.Intrinsics.Vector128<ulong> left, System.Runtime.Intrinsics.Vector128<ulong> right) { throw null; }
+            public static System.Runtime.Intrinsics.Vector64<byte> UnzipOdd (System.Runtime.Intrinsics.Vector64<byte> left, System.Runtime.Intrinsics.Vector64<byte> right) { throw null; }
+            public static System.Runtime.Intrinsics.Vector64<short> UnzipOdd (System.Runtime.Intrinsics.Vector64<short> left, System.Runtime.Intrinsics.Vector64<short> right) { throw null; }
+            public static System.Runtime.Intrinsics.Vector64<int> UnzipOdd (System.Runtime.Intrinsics.Vector64<int> left, System.Runtime.Intrinsics.Vector64<int> right) { throw null; }
+            public static System.Runtime.Intrinsics.Vector64<sbyte> UnzipOdd (System.Runtime.Intrinsics.Vector64<sbyte> left, System.Runtime.Intrinsics.Vector64<sbyte> right) { throw null; }
+            public static System.Runtime.Intrinsics.Vector64<float> UnzipOdd (System.Runtime.Intrinsics.Vector64<float> left, System.Runtime.Intrinsics.Vector64<float> right) { throw null; }
+            public static System.Runtime.Intrinsics.Vector64<ushort> UnzipOdd (System.Runtime.Intrinsics.Vector64<ushort> left, System.Runtime.Intrinsics.Vector64<ushort> right) { throw null; }
+            public static System.Runtime.Intrinsics.Vector64<uint> UnzipOdd (System.Runtime.Intrinsics.Vector64<uint> left, System.Runtime.Intrinsics.Vector64<uint> right) { throw null; }
+            public static System.Runtime.Intrinsics.Vector128<byte> UnzipOdd (System.Runtime.Intrinsics.Vector128<byte> left, System.Runtime.Intrinsics.Vector128<byte> right) { throw null; }
+            public static System.Runtime.Intrinsics.Vector128<double> UnzipOdd (System.Runtime.Intrinsics.Vector128<double> left, System.Runtime.Intrinsics.Vector128<double> right) { throw null; }
+            public static System.Runtime.Intrinsics.Vector128<short> UnzipOdd (System.Runtime.Intrinsics.Vector128<short> left, System.Runtime.Intrinsics.Vector128<short> right) { throw null; }
+            public static System.Runtime.Intrinsics.Vector128<int> UnzipOdd (System.Runtime.Intrinsics.Vector128<int> left, System.Runtime.Intrinsics.Vector128<int> right) { throw null; }
+            public static System.Runtime.Intrinsics.Vector128<long> UnzipOdd (System.Runtime.Intrinsics.Vector128<long> left, System.Runtime.Intrinsics.Vector128<long> right) { throw null; }
+            public static System.Runtime.Intrinsics.Vector128<sbyte> UnzipOdd (System.Runtime.Intrinsics.Vector128<sbyte> left, System.Runtime.Intrinsics.Vector128<sbyte> right) { throw null; }
+            public static System.Runtime.Intrinsics.Vector128<float> UnzipOdd (System.Runtime.Intrinsics.Vector128<float> left, System.Runtime.Intrinsics.Vector128<float> right) { throw null; }
+            public static System.Runtime.Intrinsics.Vector128<ushort> UnzipOdd (System.Runtime.Intrinsics.Vector128<ushort> left, System.Runtime.Intrinsics.Vector128<ushort> right) { throw null; }
+            public static System.Runtime.Intrinsics.Vector128<uint> UnzipOdd (System.Runtime.Intrinsics.Vector128<uint> left, System.Runtime.Intrinsics.Vector128<uint> right) { throw null; }
+            public static System.Runtime.Intrinsics.Vector128<ulong> UnzipOdd (System.Runtime.Intrinsics.Vector128<ulong> left, System.Runtime.Intrinsics.Vector128<ulong> right) { throw null; }
+            public static System.Runtime.Intrinsics.Vector64<byte> ZipHigh (System.Runtime.Intrinsics.Vector64<byte> left, System.Runtime.Intrinsics.Vector64<byte> right) { throw null; }
+            public static System.Runtime.Intrinsics.Vector64<short> ZipHigh (System.Runtime.Intrinsics.Vector64<short> left, System.Runtime.Intrinsics.Vector64<short> right) { throw null; }
+            public static System.Runtime.Intrinsics.Vector64<int> ZipHigh (System.Runtime.Intrinsics.Vector64<int> left, System.Runtime.Intrinsics.Vector64<int> right) { throw null; }
+            public static System.Runtime.Intrinsics.Vector64<sbyte> ZipHigh (System.Runtime.Intrinsics.Vector64<sbyte> left, System.Runtime.Intrinsics.Vector64<sbyte> right) { throw null; }
+            public static System.Runtime.Intrinsics.Vector64<float> ZipHigh (System.Runtime.Intrinsics.Vector64<float> left, System.Runtime.Intrinsics.Vector64<float> right) { throw null; }
+            public static System.Runtime.Intrinsics.Vector64<ushort> ZipHigh (System.Runtime.Intrinsics.Vector64<ushort> left, System.Runtime.Intrinsics.Vector64<ushort> right) { throw null; }
+            public static System.Runtime.Intrinsics.Vector64<uint> ZipHigh (System.Runtime.Intrinsics.Vector64<uint> left, System.Runtime.Intrinsics.Vector64<uint> right) { throw null; }
+            public static System.Runtime.Intrinsics.Vector128<byte> ZipHigh (System.Runtime.Intrinsics.Vector128<byte> left, System.Runtime.Intrinsics.Vector128<byte> right) { throw null; }
+            public static System.Runtime.Intrinsics.Vector128<double> ZipHigh (System.Runtime.Intrinsics.Vector128<double> left, System.Runtime.Intrinsics.Vector128<double> right) { throw null; }
+            public static System.Runtime.Intrinsics.Vector128<short> ZipHigh (System.Runtime.Intrinsics.Vector128<short> left, System.Runtime.Intrinsics.Vector128<short> right) { throw null; }
+            public static System.Runtime.Intrinsics.Vector128<int> ZipHigh (System.Runtime.Intrinsics.Vector128<int> left, System.Runtime.Intrinsics.Vector128<int> right) { throw null; }
+            public static System.Runtime.Intrinsics.Vector128<long> ZipHigh (System.Runtime.Intrinsics.Vector128<long> left, System.Runtime.Intrinsics.Vector128<long> right) { throw null; }
+            public static System.Runtime.Intrinsics.Vector128<sbyte> ZipHigh (System.Runtime.Intrinsics.Vector128<sbyte> left, System.Runtime.Intrinsics.Vector128<sbyte> right) { throw null; }
+            public static System.Runtime.Intrinsics.Vector128<float> ZipHigh (System.Runtime.Intrinsics.Vector128<float> left, System.Runtime.Intrinsics.Vector128<float> right) { throw null; }
+            public static System.Runtime.Intrinsics.Vector128<ushort> ZipHigh (System.Runtime.Intrinsics.Vector128<ushort> left, System.Runtime.Intrinsics.Vector128<ushort> right) { throw null; }
+            public static System.Runtime.Intrinsics.Vector128<uint> ZipHigh (System.Runtime.Intrinsics.Vector128<uint> left, System.Runtime.Intrinsics.Vector128<uint> right) { throw null; }
+            public static System.Runtime.Intrinsics.Vector128<ulong> ZipHigh (System.Runtime.Intrinsics.Vector128<ulong> left, System.Runtime.Intrinsics.Vector128<ulong> right) { throw null; }
+            public static System.Runtime.Intrinsics.Vector64<byte> ZipLow (System.Runtime.Intrinsics.Vector64<byte> left, System.Runtime.Intrinsics.Vector64<byte> right) { throw null; }
+            public static System.Runtime.Intrinsics.Vector64<short> ZipLow (System.Runtime.Intrinsics.Vector64<short> left, System.Runtime.Intrinsics.Vector64<short> right) { throw null; }
+            public static System.Runtime.Intrinsics.Vector64<int> ZipLow (System.Runtime.Intrinsics.Vector64<int> left, System.Runtime.Intrinsics.Vector64<int> right) { throw null; }
+            public static System.Runtime.Intrinsics.Vector64<sbyte> ZipLow (System.Runtime.Intrinsics.Vector64<sbyte> left, System.Runtime.Intrinsics.Vector64<sbyte> right) { throw null; }
+            public static System.Runtime.Intrinsics.Vector64<float> ZipLow (System.Runtime.Intrinsics.Vector64<float> left, System.Runtime.Intrinsics.Vector64<float> right) { throw null; }
+            public static System.Runtime.Intrinsics.Vector64<ushort> ZipLow (System.Runtime.Intrinsics.Vector64<ushort> left, System.Runtime.Intrinsics.Vector64<ushort> right) { throw null; }
+            public static System.Runtime.Intrinsics.Vector64<uint> ZipLow (System.Runtime.Intrinsics.Vector64<uint> left, System.Runtime.Intrinsics.Vector64<uint> right) { throw null; }
+            public static System.Runtime.Intrinsics.Vector128<byte> ZipLow (System.Runtime.Intrinsics.Vector128<byte> left, System.Runtime.Intrinsics.Vector128<byte> right) { throw null; }
+            public static System.Runtime.Intrinsics.Vector128<double> ZipLow (System.Runtime.Intrinsics.Vector128<double> left, System.Runtime.Intrinsics.Vector128<double> right) { throw null; }
+            public static System.Runtime.Intrinsics.Vector128<short> ZipLow (System.Runtime.Intrinsics.Vector128<short> left, System.Runtime.Intrinsics.Vector128<short> right) { throw null; }
+            public static System.Runtime.Intrinsics.Vector128<int> ZipLow (System.Runtime.Intrinsics.Vector128<int> left, System.Runtime.Intrinsics.Vector128<int> right) { throw null; }
+            public static System.Runtime.Intrinsics.Vector128<long> ZipLow (System.Runtime.Intrinsics.Vector128<long> left, System.Runtime.Intrinsics.Vector128<long> right) { throw null; }
+            public static System.Runtime.Intrinsics.Vector128<sbyte> ZipLow (System.Runtime.Intrinsics.Vector128<sbyte> left, System.Runtime.Intrinsics.Vector128<sbyte> right) { throw null; }
+            public static System.Runtime.Intrinsics.Vector128<float> ZipLow (System.Runtime.Intrinsics.Vector128<float> left, System.Runtime.Intrinsics.Vector128<float> right) { throw null; }
+            public static System.Runtime.Intrinsics.Vector128<ushort> ZipLow (System.Runtime.Intrinsics.Vector128<ushort> left, System.Runtime.Intrinsics.Vector128<ushort> right) { throw null; }
+            public static System.Runtime.Intrinsics.Vector128<uint> ZipLow (System.Runtime.Intrinsics.Vector128<uint> left, System.Runtime.Intrinsics.Vector128<uint> right) { throw null; }
+            public static System.Runtime.Intrinsics.Vector128<ulong> ZipLow (System.Runtime.Intrinsics.Vector128<ulong> left, System.Runtime.Intrinsics.Vector128<ulong> right) { throw null; }
         }
     }
     [System.CLSCompliantAttribute(false)]
@@ -240,6 +322,9 @@ namespace System.Runtime.Intrinsics.Arm
         public static bool IsSupported { get { throw null; } }
         public static int LeadingZeroCount(int value) { throw null; }
         public static int LeadingZeroCount(uint value) { throw null; }
+        public static int ReverseElementBits(int value) { throw null; }
+        public static uint ReverseElementBits(uint value) { throw null; }
+
         public abstract partial class Arm64
         {
             internal Arm64() { }
@@ -248,6 +333,8 @@ namespace System.Runtime.Intrinsics.Arm
             public static int LeadingSignCount(long value) { throw null; }
             public static int LeadingZeroCount(long value) { throw null; }
             public static int LeadingZeroCount(ulong value) { throw null; }
+            public static long ReverseElementBits(long  value) { throw null; }
+            public static ulong ReverseElementBits(ulong value) { throw null; }
         }
     }
     [System.CLSCompliantAttribute(false)]