diff --git a/release-notes/9.0/preview/preview6/api-diff/Microsoft.AspNetCore.App/9.0-preview6.md b/release-notes/9.0/preview/preview6/api-diff/Microsoft.AspNetCore.App/9.0-preview6.md new file mode 100644 index 0000000000..2826817edd --- /dev/null +++ b/release-notes/9.0/preview/preview6/api-diff/Microsoft.AspNetCore.App/9.0-preview6.md @@ -0,0 +1,16 @@ +# API Difference 9.0-preview5 vs 9.0-preview6 + +API listing follows standard diff formatting. +Lines preceded by a '+' are additions and a '-' indicates removal. + +* [Microsoft.AspNetCore.Authentication](9.0-preview6_Microsoft.AspNetCore.Authentication.md) +* [Microsoft.AspNetCore.Builder](9.0-preview6_Microsoft.AspNetCore.Builder.md) +* [Microsoft.AspNetCore.Components](9.0-preview6_Microsoft.AspNetCore.Components.md) +* [Microsoft.AspNetCore.Components.HtmlRendering.Infrastructure](9.0-preview6_Microsoft.AspNetCore.Components.HtmlRendering.Infrastructure.md) +* [Microsoft.AspNetCore.Components.RenderTree](9.0-preview6_Microsoft.AspNetCore.Components.RenderTree.md) +* [Microsoft.AspNetCore.Cors.Infrastructure](9.0-preview6_Microsoft.AspNetCore.Cors.Infrastructure.md) +* [Microsoft.AspNetCore.Mvc.TagHelpers](9.0-preview6_Microsoft.AspNetCore.Mvc.TagHelpers.md) +* [Microsoft.AspNetCore.StaticAssets](9.0-preview6_Microsoft.AspNetCore.StaticAssets.md) +* [Microsoft.AspNetCore.StaticAssets.Infrastructure](9.0-preview6_Microsoft.AspNetCore.StaticAssets.Infrastructure.md) +* [Microsoft.AspNetCore.WebUtilities](9.0-preview6_Microsoft.AspNetCore.WebUtilities.md) + diff --git a/release-notes/9.0/preview/preview6/api-diff/Microsoft.AspNetCore.App/9.0-preview6_Microsoft.AspNetCore.Authentication.md b/release-notes/9.0/preview/preview6/api-diff/Microsoft.AspNetCore.App/9.0-preview6_Microsoft.AspNetCore.Authentication.md new file mode 100644 index 0000000000..e44c521a81 --- /dev/null +++ b/release-notes/9.0/preview/preview6/api-diff/Microsoft.AspNetCore.App/9.0-preview6_Microsoft.AspNetCore.Authentication.md @@ -0,0 +1,11 @@ +# Microsoft.AspNetCore.Authentication + +``` diff + namespace Microsoft.AspNetCore.Authentication { + public abstract class ResultContext<TOptions> : BaseContext<TOptions> where TOptions : AuthenticationSchemeOptions { +- public AuthenticateResult Result { get; } ++ public AuthenticateResult? Result { get; } + } + } +``` + diff --git a/release-notes/9.0/preview/preview6/api-diff/Microsoft.AspNetCore.App/9.0-preview6_Microsoft.AspNetCore.Builder.md b/release-notes/9.0/preview/preview6/api-diff/Microsoft.AspNetCore.App/9.0-preview6_Microsoft.AspNetCore.Builder.md new file mode 100644 index 0000000000..d9c40ef4ed --- /dev/null +++ b/release-notes/9.0/preview/preview6/api-diff/Microsoft.AspNetCore.App/9.0-preview6_Microsoft.AspNetCore.Builder.md @@ -0,0 +1,16 @@ +# Microsoft.AspNetCore.Builder + +``` diff + namespace Microsoft.AspNetCore.Builder { ++ public static class ControllerActionEndpointConventionBuilderResourceCollectionExtensions { ++ public static ControllerActionEndpointConventionBuilder WithStaticAssets(this ControllerActionEndpointConventionBuilder builder, string manifestPath = null); ++ } ++ public static class PageActionEndpointConventionBuilderResourceCollectionExtensions { ++ public static PageActionEndpointConventionBuilder WithStaticAssets(this PageActionEndpointConventionBuilder builder, string? manifestPath = null); ++ } + public static class RazorComponentsEndpointConventionBuilderExtensions { ++ public static RazorComponentsEndpointConventionBuilder WithStaticAssets(this RazorComponentsEndpointConventionBuilder builder, string? manifestPath = null); + } + } +``` + diff --git a/release-notes/9.0/preview/preview6/api-diff/Microsoft.AspNetCore.App/9.0-preview6_Microsoft.AspNetCore.Components.HtmlRendering.Infrastructure.md b/release-notes/9.0/preview/preview6/api-diff/Microsoft.AspNetCore.App/9.0-preview6_Microsoft.AspNetCore.Components.HtmlRendering.Infrastructure.md new file mode 100644 index 0000000000..a16ecc5853 --- /dev/null +++ b/release-notes/9.0/preview/preview6/api-diff/Microsoft.AspNetCore.App/9.0-preview6_Microsoft.AspNetCore.Components.HtmlRendering.Infrastructure.md @@ -0,0 +1,12 @@ +# Microsoft.AspNetCore.Components.HtmlRendering.Infrastructure + +``` diff + namespace Microsoft.AspNetCore.Components.HtmlRendering.Infrastructure { + public class StaticHtmlRenderer : Renderer { +- protected internal override ComponentPlatform ComponentPlatform { get; } + ++ protected internal override RendererInfo RendererInfo { get; } + } + } +``` + diff --git a/release-notes/9.0/preview/preview6/api-diff/Microsoft.AspNetCore.App/9.0-preview6_Microsoft.AspNetCore.Components.RenderTree.md b/release-notes/9.0/preview/preview6/api-diff/Microsoft.AspNetCore.App/9.0-preview6_Microsoft.AspNetCore.Components.RenderTree.md new file mode 100644 index 0000000000..a6a9706970 --- /dev/null +++ b/release-notes/9.0/preview/preview6/api-diff/Microsoft.AspNetCore.App/9.0-preview6_Microsoft.AspNetCore.Components.RenderTree.md @@ -0,0 +1,13 @@ +# Microsoft.AspNetCore.Components.RenderTree + +``` diff + namespace Microsoft.AspNetCore.Components.RenderTree { + public abstract class Renderer : IAsyncDisposable, IDisposable { ++ protected internal virtual ResourceAssetCollection Assets { get; } +- protected internal virtual ComponentPlatform ComponentPlatform { get; } + ++ protected internal virtual RendererInfo RendererInfo { get; } + } + } +``` + diff --git a/release-notes/9.0/preview/preview6/api-diff/Microsoft.AspNetCore.App/9.0-preview6_Microsoft.AspNetCore.Components.md b/release-notes/9.0/preview/preview6/api-diff/Microsoft.AspNetCore.App/9.0-preview6_Microsoft.AspNetCore.Components.md new file mode 100644 index 0000000000..ce4acd6fa9 --- /dev/null +++ b/release-notes/9.0/preview/preview6/api-diff/Microsoft.AspNetCore.App/9.0-preview6_Microsoft.AspNetCore.Components.md @@ -0,0 +1,69 @@ +# Microsoft.AspNetCore.Components + +``` diff + namespace Microsoft.AspNetCore.Components { + public abstract class ComponentBase : IComponent, IHandleAfterRender, IHandleEvent { ++ protected ResourceAssetCollection Assets { get; } +- protected ComponentPlatform Platform { get; } + ++ protected RendererInfo RendererInfo { get; } + } +- public sealed class ComponentPlatform { + { +- public ComponentPlatform(string platformName, bool isInteractive); + +- public bool IsInteractive { get; } + +- public string Name { get; } + +- } ++ public sealed class ImportMap : IComponent { ++ public ImportMap(); ++ public HttpContext HttpContext { get; set; } ++ public ImportMapDefinition ImportMapDefinition { get; set; } ++ void IComponent.Attach(RenderHandle renderHandle); ++ Task IComponent.SetParametersAsync(ParameterView parameters); ++ } ++ public sealed class ImportMapDefinition { ++ public ImportMapDefinition(IReadOnlyDictionary<string, string>? imports, IReadOnlyDictionary<string, IReadOnlyDictionary<string, string>>? scopes, IReadOnlyDictionary<string, string>? integrity); ++ public IReadOnlyDictionary<string, string>? Imports { get; } ++ public IReadOnlyDictionary<string, string>? Integrity { get; } ++ public IReadOnlyDictionary<string, IReadOnlyDictionary<string, string>>? Scopes { get; } ++ public static ImportMapDefinition Combine(params ImportMapDefinition[] sources); ++ public static ImportMapDefinition FromResourceCollection(ResourceAssetCollection assets); ++ public override string ToString(); ++ } ++ public sealed class RendererInfo { ++ public RendererInfo(string rendererName, bool isInteractive); ++ public bool IsInteractive { get; } ++ public string Name { get; } ++ } + public readonly struct RenderHandle { ++ public ResourceAssetCollection Assets { get; } +- public ComponentPlatform Platform { get; } + ++ public RendererInfo RendererInfo { get; } + } ++ public sealed class ResourceAsset { ++ public ResourceAsset(string url, IReadOnlyList<ResourceAssetProperty>? properties); ++ public IReadOnlyList<ResourceAssetProperty>? Properties { get; } ++ public string Url { get; } ++ } ++ public sealed class ResourceAssetCollection : IEnumerable, IEnumerable<ResourceAsset>, IReadOnlyCollection<ResourceAsset>, IReadOnlyList<ResourceAsset> { ++ public static readonly ResourceAssetCollection Empty; ++ public ResourceAssetCollection(IReadOnlyList<ResourceAsset> resources); ++ int IReadOnlyCollection<ResourceAsset>.Count { get; } ++ ResourceAsset IReadOnlyList<ResourceAsset>.this[int index] { get; } ++ public string this[string key] { get; } ++ public bool IsContentSpecificUrl(string path); ++ IEnumerator<ResourceAsset> IEnumerable<ResourceAsset>.GetEnumerator(); ++ IEnumerator IEnumerable.GetEnumerator(); ++ } ++ public sealed class ResourceAssetProperty { ++ public ResourceAssetProperty(string name, string value); ++ public string Name { get; } ++ public string Value { get; } ++ } + } +``` + diff --git a/release-notes/9.0/preview/preview6/api-diff/Microsoft.AspNetCore.App/9.0-preview6_Microsoft.AspNetCore.Cors.Infrastructure.md b/release-notes/9.0/preview/preview6/api-diff/Microsoft.AspNetCore.App/9.0-preview6_Microsoft.AspNetCore.Cors.Infrastructure.md new file mode 100644 index 0000000000..0559604347 --- /dev/null +++ b/release-notes/9.0/preview/preview6/api-diff/Microsoft.AspNetCore.App/9.0-preview6_Microsoft.AspNetCore.Cors.Infrastructure.md @@ -0,0 +1,11 @@ +# Microsoft.AspNetCore.Cors.Infrastructure + +``` diff + namespace Microsoft.AspNetCore.Cors.Infrastructure { + public static class CorsConstants { ++ public static readonly string AnyHeader; ++ public static readonly string AnyMethod; + } + } +``` + diff --git a/release-notes/9.0/preview/preview6/api-diff/Microsoft.AspNetCore.App/9.0-preview6_Microsoft.AspNetCore.Mvc.TagHelpers.md b/release-notes/9.0/preview/preview6/api-diff/Microsoft.AspNetCore.App/9.0-preview6_Microsoft.AspNetCore.Mvc.TagHelpers.md new file mode 100644 index 0000000000..7a52694353 --- /dev/null +++ b/release-notes/9.0/preview/preview6/api-diff/Microsoft.AspNetCore.App/9.0-preview6_Microsoft.AspNetCore.Mvc.TagHelpers.md @@ -0,0 +1,11 @@ +# Microsoft.AspNetCore.Mvc.TagHelpers + +``` diff + namespace Microsoft.AspNetCore.Mvc.TagHelpers { + public class ScriptTagHelper : UrlResolutionTagHelper { ++ public ImportMapDefinition ImportMap { get; set; } ++ public string Type { get; set; } + } + } +``` + diff --git a/release-notes/9.0/preview/preview6/api-diff/Microsoft.AspNetCore.App/9.0-preview6_Microsoft.AspNetCore.StaticAssets.Infrastructure.md b/release-notes/9.0/preview/preview6/api-diff/Microsoft.AspNetCore.App/9.0-preview6_Microsoft.AspNetCore.StaticAssets.Infrastructure.md new file mode 100644 index 0000000000..168286660f --- /dev/null +++ b/release-notes/9.0/preview/preview6/api-diff/Microsoft.AspNetCore.App/9.0-preview6_Microsoft.AspNetCore.StaticAssets.Infrastructure.md @@ -0,0 +1,13 @@ +# Microsoft.AspNetCore.StaticAssets.Infrastructure + +``` diff + namespace Microsoft.AspNetCore.StaticAssets.Infrastructure { + public static class StaticAssetsEndpointDataSourceHelper { ++ public static bool HasStaticAssetsDataSource(IEndpointRouteBuilder builder, string? staticAssetsManifestPath = null); +- public static bool IsStaticAssetsDataSource(EndpointDataSource dataSource, string? staticAssetsManifestPath = null); + ++ public static IReadOnlyList<StaticAssetDescriptor> ResolveStaticAssetDescriptors(IEndpointRouteBuilder endpointRouteBuilder, string? manifestPath); + } + } +``` + diff --git a/release-notes/9.0/preview/preview6/api-diff/Microsoft.AspNetCore.App/9.0-preview6_Microsoft.AspNetCore.StaticAssets.md b/release-notes/9.0/preview/preview6/api-diff/Microsoft.AspNetCore.App/9.0-preview6_Microsoft.AspNetCore.StaticAssets.md new file mode 100644 index 0000000000..a80fc554c4 --- /dev/null +++ b/release-notes/9.0/preview/preview6/api-diff/Microsoft.AspNetCore.App/9.0-preview6_Microsoft.AspNetCore.StaticAssets.md @@ -0,0 +1,31 @@ +# Microsoft.AspNetCore.StaticAssets + +``` diff + namespace Microsoft.AspNetCore.StaticAssets { ++ public sealed class StaticAssetDescriptor { ++ public StaticAssetDescriptor(); ++ public string AssetPath { get; set; } ++ public IReadOnlyList<StaticAssetProperty> Properties { get; set; } ++ public IReadOnlyList<StaticAssetResponseHeader> ResponseHeaders { get; set; } ++ public string Route { get; set; } ++ public IReadOnlyList<StaticAssetSelector> Selectors { get; set; } ++ } ++ public sealed class StaticAssetProperty { ++ public StaticAssetProperty(string name, string value); ++ public string Name { get; } ++ public string Value { get; } ++ } ++ public sealed class StaticAssetResponseHeader { ++ public StaticAssetResponseHeader(string name, string value); ++ public string Name { get; } ++ public string Value { get; } ++ } ++ public sealed class StaticAssetSelector { ++ public StaticAssetSelector(string name, string value, string quality); ++ public string Name { get; } ++ public string Quality { get; } ++ public string Value { get; } ++ } + } +``` + diff --git a/release-notes/9.0/preview/preview6/api-diff/Microsoft.AspNetCore.App/9.0-preview6_Microsoft.AspNetCore.WebUtilities.md b/release-notes/9.0/preview/preview6/api-diff/Microsoft.AspNetCore.App/9.0-preview6_Microsoft.AspNetCore.WebUtilities.md new file mode 100644 index 0000000000..0a1863afc9 --- /dev/null +++ b/release-notes/9.0/preview/preview6/api-diff/Microsoft.AspNetCore.App/9.0-preview6_Microsoft.AspNetCore.WebUtilities.md @@ -0,0 +1,10 @@ +# Microsoft.AspNetCore.WebUtilities + +``` diff + namespace Microsoft.AspNetCore.WebUtilities { + public static class WebEncoders { ++ public static int Base64UrlEncode(ReadOnlySpan<byte> input, Span<char> output); + } + } +``` + diff --git a/release-notes/9.0/preview/preview6/api-diff/Microsoft.NETCore.App/9.0-preview6.md b/release-notes/9.0/preview/preview6/api-diff/Microsoft.NETCore.App/9.0-preview6.md new file mode 100644 index 0000000000..6f6dfe0dee --- /dev/null +++ b/release-notes/9.0/preview/preview6/api-diff/Microsoft.NETCore.App/9.0-preview6.md @@ -0,0 +1,33 @@ +# API Difference 9.0-preview5 vs 9.0-preview6 + +API listing follows standard diff formatting. +Lines preceded by a '+' are additions and a '-' indicates removal. + +* [System](9.0-preview6_System.md) +* [System.Buffers.Text](9.0-preview6_System.Buffers.Text.md) +* [System.Collections.Concurrent](9.0-preview6_System.Collections.Concurrent.md) +* [System.Collections.Frozen](9.0-preview6_System.Collections.Frozen.md) +* [System.Collections.Generic](9.0-preview6_System.Collections.Generic.md) +* [System.Collections.ObjectModel](9.0-preview6_System.Collections.ObjectModel.md) +* [System.Diagnostics](9.0-preview6_System.Diagnostics.md) +* [System.Diagnostics.Metrics](9.0-preview6_System.Diagnostics.Metrics.md) +* [System.IO](9.0-preview6_System.IO.md) +* [System.Net.Http](9.0-preview6_System.Net.Http.md) +* [System.Net.Mime](9.0-preview6_System.Net.Mime.md) +* [System.Net.Sockets](9.0-preview6_System.Net.Sockets.md) +* [System.Numerics](9.0-preview6_System.Numerics.md) +* [System.Reflection.Emit](9.0-preview6_System.Reflection.Emit.md) +* [System.Runtime.InteropServices](9.0-preview6_System.Runtime.InteropServices.md) +* [System.Runtime.InteropServices.Marshalling](9.0-preview6_System.Runtime.InteropServices.Marshalling.md) +* [System.Runtime.InteropServices.Swift](9.0-preview6_System.Runtime.InteropServices.Swift.md) +* [System.Runtime.Intrinsics](9.0-preview6_System.Runtime.Intrinsics.md) +* [System.Runtime.Intrinsics.Arm](9.0-preview6_System.Runtime.Intrinsics.Arm.md) +* [System.Runtime.Intrinsics.X86](9.0-preview6_System.Runtime.Intrinsics.X86.md) +* [System.Security.Cryptography](9.0-preview6_System.Security.Cryptography.md) +* [System.Text.Json](9.0-preview6_System.Text.Json.md) +* [System.Text.Json.Nodes](9.0-preview6_System.Text.Json.Nodes.md) +* [System.Text.Json.Schema](9.0-preview6_System.Text.Json.Schema.md) +* [System.Text.Json.Serialization](9.0-preview6_System.Text.Json.Serialization.md) +* [System.Text.Json.Serialization.Metadata](9.0-preview6_System.Text.Json.Serialization.Metadata.md) +* [System.Text.RegularExpressions](9.0-preview6_System.Text.RegularExpressions.md) + diff --git a/release-notes/9.0/preview/preview6/api-diff/Microsoft.NETCore.App/9.0-preview6_System.Buffers.Text.md b/release-notes/9.0/preview/preview6/api-diff/Microsoft.NETCore.App/9.0-preview6_System.Buffers.Text.md new file mode 100644 index 0000000000..7e3633f6cf --- /dev/null +++ b/release-notes/9.0/preview/preview6/api-diff/Microsoft.NETCore.App/9.0-preview6_System.Buffers.Text.md @@ -0,0 +1,34 @@ +# System.Buffers.Text + +``` diff + namespace System.Buffers.Text { ++ public static class Base64Url { ++ public static byte[] DecodeFromChars(ReadOnlySpan<char> source); ++ public static int DecodeFromChars(ReadOnlySpan<char> source, Span<byte> destination); ++ public static OperationStatus DecodeFromChars(ReadOnlySpan<char> source, Span<byte> destination, out int charsConsumed, out int bytesWritten, bool isFinalBlock = true); ++ public static byte[] DecodeFromUtf8(ReadOnlySpan<byte> source); ++ public static int DecodeFromUtf8(ReadOnlySpan<byte> source, Span<byte> destination); ++ public static OperationStatus DecodeFromUtf8(ReadOnlySpan<byte> source, Span<byte> destination, out int bytesConsumed, out int bytesWritten, bool isFinalBlock = true); ++ public static int DecodeFromUtf8InPlace(Span<byte> buffer); ++ public static char[] EncodeToChars(ReadOnlySpan<byte> source); ++ public static int EncodeToChars(ReadOnlySpan<byte> source, Span<char> destination); ++ public static OperationStatus EncodeToChars(ReadOnlySpan<byte> source, Span<char> destination, out int bytesConsumed, out int charsWritten, bool isFinalBlock = true); ++ public static string EncodeToString(ReadOnlySpan<byte> source); ++ public static byte[] EncodeToUtf8(ReadOnlySpan<byte> source); ++ public static int EncodeToUtf8(ReadOnlySpan<byte> source, Span<byte> destination); ++ public static OperationStatus EncodeToUtf8(ReadOnlySpan<byte> source, Span<byte> destination, out int bytesConsumed, out int bytesWritten, bool isFinalBlock = true); ++ public static int GetEncodedLength(int bytesLength); ++ public static int GetMaxDecodedLength(int base64Length); ++ public static bool IsValid(ReadOnlySpan<byte> utf8Base64UrlText); ++ public static bool IsValid(ReadOnlySpan<byte> utf8Base64UrlText, out int decodedLength); ++ public static bool IsValid(ReadOnlySpan<char> base64UrlText); ++ public static bool IsValid(ReadOnlySpan<char> base64UrlText, out int decodedLength); ++ public static bool TryDecodeFromChars(ReadOnlySpan<char> source, Span<byte> destination, out int bytesWritten); ++ public static bool TryDecodeFromUtf8(ReadOnlySpan<byte> source, Span<byte> destination, out int bytesWritten); ++ public static bool TryEncodeToChars(ReadOnlySpan<byte> source, Span<char> destination, out int charsWritten); ++ public static bool TryEncodeToUtf8(ReadOnlySpan<byte> source, Span<byte> destination, out int bytesWritten); ++ public static bool TryEncodeToUtf8InPlace(Span<byte> buffer, int dataLength, out int bytesWritten); ++ } + } +``` + diff --git a/release-notes/9.0/preview/preview6/api-diff/Microsoft.NETCore.App/9.0-preview6_System.Collections.Concurrent.md b/release-notes/9.0/preview/preview6/api-diff/Microsoft.NETCore.App/9.0-preview6_System.Collections.Concurrent.md new file mode 100644 index 0000000000..37c29ef172 --- /dev/null +++ b/release-notes/9.0/preview/preview6/api-diff/Microsoft.NETCore.App/9.0-preview6_System.Collections.Concurrent.md @@ -0,0 +1,21 @@ +# System.Collections.Concurrent + +``` diff + namespace System.Collections.Concurrent { + public class ConcurrentDictionary<TKey, TValue> : ICollection, ICollection<KeyValuePair<TKey, TValue>>, IDictionary, IDictionary<TKey, TValue>, IEnumerable, IEnumerable<KeyValuePair<TKey, TValue>>, IReadOnlyCollection<KeyValuePair<TKey, TValue>>, IReadOnlyDictionary<TKey, TValue> { ++ public ConcurrentDictionary.AlternateLookup<TAlternateKey> GetAlternateLookup<TAlternateKey>(); ++ public bool TryGetAlternateLookup<TAlternateKey>(out ConcurrentDictionary.AlternateLookup<TAlternateKey> lookup); ++ public readonly struct AlternateLookup<TAlternateKey> { ++ public ConcurrentDictionary<TKey, TValue> Dictionary { get; } ++ public TValue this[TAlternateKey key] { get; set; } ++ public bool ContainsKey(TAlternateKey key); ++ public bool TryAdd(TAlternateKey key, TValue value); ++ public bool TryGetValue(TAlternateKey key, out TKey actualKey, out TValue value); ++ public bool TryGetValue(TAlternateKey key, out TValue value); ++ public bool TryRemove(TAlternateKey key, out TKey actualKey, out TValue value); ++ public bool TryRemove(TAlternateKey key, out TValue value); ++ } + } + } +``` + diff --git a/release-notes/9.0/preview/preview6/api-diff/Microsoft.NETCore.App/9.0-preview6_System.Collections.Frozen.md b/release-notes/9.0/preview/preview6/api-diff/Microsoft.NETCore.App/9.0-preview6_System.Collections.Frozen.md new file mode 100644 index 0000000000..6a4a0b77e3 --- /dev/null +++ b/release-notes/9.0/preview/preview6/api-diff/Microsoft.NETCore.App/9.0-preview6_System.Collections.Frozen.md @@ -0,0 +1,26 @@ +# System.Collections.Frozen + +``` diff + namespace System.Collections.Frozen { + public abstract class FrozenDictionary<TKey, TValue> : ICollection, ICollection<KeyValuePair<TKey, TValue>>, IDictionary, IDictionary<TKey, TValue>, IEnumerable, IEnumerable<KeyValuePair<TKey, TValue>>, IReadOnlyCollection<KeyValuePair<TKey, TValue>>, IReadOnlyDictionary<TKey, TValue> { ++ public FrozenDictionary.AlternateLookup<TAlternateKey> GetAlternateLookup<TAlternateKey>(); ++ public bool TryGetAlternateLookup<TAlternateKey>(out FrozenDictionary.AlternateLookup<TAlternateKey> lookup); ++ public readonly struct AlternateLookup<TAlternateKey> { ++ public FrozenDictionary<TKey, TValue> Dictionary { get; } ++ public TValue this[TAlternateKey key] { get; } ++ public bool ContainsKey(TAlternateKey key); ++ public bool TryGetValue(TAlternateKey key, out TValue value); ++ } + } + public abstract class FrozenSet<T> : ICollection, ICollection<T>, IEnumerable, IEnumerable<T>, IReadOnlyCollection<T>, IReadOnlySet<T>, ISet<T> { ++ public FrozenSet.AlternateLookup<TAlternate> GetAlternateLookup<TAlternate>(); ++ public bool TryGetAlternateLookup<TAlternate>(out FrozenSet.AlternateLookup<TAlternate> lookup); ++ public readonly struct AlternateLookup<TAlternate> { ++ public FrozenSet<T> Set { get; } ++ public bool Contains(TAlternate item); ++ public bool TryGetValue(TAlternate equalValue, out T actualValue); ++ } + } + } +``` + diff --git a/release-notes/9.0/preview/preview6/api-diff/Microsoft.NETCore.App/9.0-preview6_System.Collections.Generic.md b/release-notes/9.0/preview/preview6/api-diff/Microsoft.NETCore.App/9.0-preview6_System.Collections.Generic.md new file mode 100644 index 0000000000..b9728652b2 --- /dev/null +++ b/release-notes/9.0/preview/preview6/api-diff/Microsoft.NETCore.App/9.0-preview6_System.Collections.Generic.md @@ -0,0 +1,192 @@ +# System.Collections.Generic + +``` diff + namespace System.Collections.Generic { + public static class CollectionExtensions { ++ public static HashSet.AlternateLookup<TAlternate> GetAlternateLookup<T, TAlternate>(this HashSet<T> @set); ++ public static Dictionary.AlternateLookup<TAlternateKey> GetAlternateLookup<TKey, TValue, TAlternateKey>(this Dictionary<TKey, TValue> dictionary); ++ public static bool TryGetAlternateLookup<T, TAlternate>(this HashSet<T> @set, out HashSet.AlternateLookup<TAlternate> lookup); ++ public static bool TryGetAlternateLookup<TKey, TValue, TAlternateKey>(this Dictionary<TKey, TValue> dictionary, out Dictionary.AlternateLookup<TAlternateKey> lookup); + } + public class Dictionary<TKey, TValue> : ICollection, ICollection<KeyValuePair<TKey, TValue>>, IDeserializationCallback, IDictionary, IDictionary<TKey, TValue>, IEnumerable, IEnumerable<KeyValuePair<TKey, TValue>>, IReadOnlyCollection<KeyValuePair<TKey, TValue>>, IReadOnlyDictionary<TKey, TValue>, ISerializable { ++ public readonly struct AlternateLookup<TAlternateKey> { ++ public Dictionary<TKey, TValue> Dictionary { get; } ++ public TValue this[TAlternateKey key] { get; set; } ++ public bool ContainsKey(TAlternateKey key); ++ public bool Remove(TAlternateKey key); ++ public bool Remove(TAlternateKey key, out TKey actualKey, out TValue value); ++ public bool TryAdd(TAlternateKey key, TValue value); ++ public bool TryGetValue(TAlternateKey key, out TKey actualKey, out TValue value); ++ public bool TryGetValue(TAlternateKey key, out TValue value); ++ } + } + public class HashSet<T> : ICollection<T>, IDeserializationCallback, IEnumerable, IEnumerable<T>, IReadOnlyCollection<T>, IReadOnlySet<T>, ISerializable, ISet<T> { ++ public readonly struct AlternateLookup<TAlternate> { ++ public HashSet<T> Set { get; } ++ public bool Add(TAlternate item); ++ public bool Contains(TAlternate item); ++ public bool Remove(TAlternate item); ++ public bool TryGetValue(TAlternate equalValue, out T actualValue); ++ } + } ++ public interface IAlternateEqualityComparer<in TAlternate, T> { ++ T Create(TAlternate alternate); ++ bool Equals(TAlternate alternate, T other); ++ int GetHashCode(TAlternate alternate); ++ } ++ public class OrderedDictionary<TKey, TValue> : ICollection, ICollection<KeyValuePair<TKey, TValue>>, IDictionary, IDictionary<TKey, TValue>, IEnumerable, IEnumerable<KeyValuePair<TKey, TValue>>, IList, IList<KeyValuePair<TKey, TValue>>, IReadOnlyCollection<KeyValuePair<TKey, TValue>>, IReadOnlyDictionary<TKey, TValue>, IReadOnlyList<KeyValuePair<TKey, TValue>> { ++ public OrderedDictionary(); ++ public OrderedDictionary(IDictionary<TKey, TValue> dictionary); ++ public OrderedDictionary(IDictionary<TKey, TValue> dictionary, IEqualityComparer<TKey>? comparer); ++ public OrderedDictionary(IEnumerable<KeyValuePair<TKey, TValue>> collection); ++ public OrderedDictionary(IEnumerable<KeyValuePair<TKey, TValue>> collection, IEqualityComparer<TKey>? comparer); ++ public OrderedDictionary(IEqualityComparer<TKey>? comparer); ++ public OrderedDictionary(int capacity); ++ public OrderedDictionary(int capacity, IEqualityComparer<TKey>? comparer); ++ public int Capacity { get; } ++ public IEqualityComparer<TKey> Comparer { get; } ++ public int Count { get; } ++ public OrderedDictionary<TKey, TValue>.KeyCollection Keys { get; } ++ bool ICollection<KeyValuePair<TKey, TValue>>.IsReadOnly { get; } ++ ICollection<TKey> IDictionary<TKey, TValue>.Keys { get; } ++ ICollection<TValue> IDictionary<TKey, TValue>.Values { get; } ++ KeyValuePair<TKey, TValue> IList<KeyValuePair<TKey, TValue>>.this[int index] { get; set; } ++ IEnumerable<TKey> IReadOnlyDictionary<TKey, TValue>.Keys { get; } ++ IEnumerable<TValue> IReadOnlyDictionary<TKey, TValue>.Values { get; } ++ KeyValuePair<TKey, TValue> IReadOnlyList<KeyValuePair<TKey, TValue>>.this[int index] { get; } ++ bool ICollection.IsSynchronized { get; } ++ object ICollection.SyncRoot { get; } ++ bool IDictionary.IsFixedSize { get; } ++ bool IDictionary.IsReadOnly { get; } ++ object? IDictionary.this[object key] { get; set; } ++ ICollection IDictionary.Keys { get; } ++ ICollection IDictionary.Values { get; } ++ bool IList.IsFixedSize { get; } ++ bool IList.IsReadOnly { get; } ++ object? IList.this[int index] { get; set; } ++ public TValue this[TKey key] { get; set; } ++ public OrderedDictionary<TKey, TValue>.ValueCollection Values { get; } ++ public void Add(TKey key, TValue value); ++ public void Clear(); ++ public bool ContainsKey(TKey key); ++ public bool ContainsValue(TValue value); ++ public int EnsureCapacity(int capacity); ++ public KeyValuePair<TKey, TValue> GetAt(int index); ++ public OrderedDictionary<TKey, TValue>.Enumerator GetEnumerator(); ++ public int IndexOf(TKey key); ++ public void Insert(int index, TKey key, TValue value); ++ public bool Remove(TKey key); ++ public bool Remove(TKey key, out TValue value); ++ public void RemoveAt(int index); ++ public void SetAt(int index, TKey key, TValue value); ++ public void SetAt(int index, TValue value); ++ void ICollection<KeyValuePair<TKey, TValue>>.Add(KeyValuePair<TKey, TValue> item); ++ bool ICollection<KeyValuePair<TKey, TValue>>.Contains(KeyValuePair<TKey, TValue> item); ++ void ICollection<KeyValuePair<TKey, TValue>>.CopyTo(KeyValuePair<TKey, TValue>[] array, int arrayIndex); ++ bool ICollection<KeyValuePair<TKey, TValue>>.Remove(KeyValuePair<TKey, TValue> item); ++ IEnumerator<KeyValuePair<TKey, TValue>> IEnumerable<KeyValuePair<TKey, TValue>>.GetEnumerator(); ++ int IList<KeyValuePair<TKey, TValue>>.IndexOf(KeyValuePair<TKey, TValue> item); ++ void IList<KeyValuePair<TKey, TValue>>.Insert(int index, KeyValuePair<TKey, TValue> item); ++ void ICollection.CopyTo(Array array, int index); ++ void IDictionary.Add(object key, object value); ++ bool IDictionary.Contains(object key); ++ IDictionaryEnumerator IDictionary.GetEnumerator(); ++ void IDictionary.Remove(object key); ++ IEnumerator IEnumerable.GetEnumerator(); ++ int IList.Add(object value); ++ bool IList.Contains(object value); ++ int IList.IndexOf(object value); ++ void IList.Insert(int index, object value); ++ void IList.Remove(object value); ++ public void TrimExcess(); ++ public void TrimExcess(int capacity); ++ public bool TryAdd(TKey key, TValue value); ++ public bool TryGetValue(TKey key, out TValue value); ++ public struct Enumerator : IDictionaryEnumerator, IDisposable, IEnumerator, IEnumerator<KeyValuePair<TKey, TValue>> { ++ public KeyValuePair<TKey, TValue> Current { get; } ++ DictionaryEntry System.Collections.IDictionaryEnumerator.Entry { get; } ++ object System.Collections.IDictionaryEnumerator.Key { get; } ++ object? System.Collections.IDictionaryEnumerator.Value { get; } ++ object System.Collections.IEnumerator.Current { get; } ++ public bool MoveNext(); ++ void System.Collections.IEnumerator.Reset(); ++ void System.IDisposable.Dispose(); ++ } ++ public sealed class KeyCollection : ICollection, ICollection<TKey>, IEnumerable, IEnumerable<TKey>, IList, IList<TKey>, IReadOnlyCollection<TKey>, IReadOnlyList<TKey> { ++ public int Count { get; } ++ bool ICollection<TKey>.IsReadOnly { get; } ++ TKey IList<TKey>.this[int index] { get; set; } ++ TKey IReadOnlyList<TKey>.this[int index] { get; } ++ bool System.Collections.ICollection.IsSynchronized { get; } ++ object System.Collections.ICollection.SyncRoot { get; } ++ bool System.Collections.IList.IsFixedSize { get; } ++ bool System.Collections.IList.IsReadOnly { get; } ++ object? System.Collections.IList.this[int index] { get; set; } ++ public bool Contains(TKey key); ++ public void CopyTo(TKey[] array, int arrayIndex); ++ public OrderedDictionary<TKey, TValue>.KeyCollection.Enumerator GetEnumerator(); ++ void ICollection<TKey>.Add(TKey item); ++ void ICollection<TKey>.Clear(); ++ bool ICollection<TKey>.Remove(TKey item); ++ IEnumerator<TKey> IEnumerable<TKey>.GetEnumerator(); ++ int IList<TKey>.IndexOf(TKey item); ++ void IList<TKey>.Insert(int index, TKey item); ++ void IList<TKey>.RemoveAt(int index); ++ void System.Collections.ICollection.CopyTo(Array array, int index); ++ IEnumerator System.Collections.IEnumerable.GetEnumerator(); ++ int System.Collections.IList.Add(object value); ++ void System.Collections.IList.Clear(); ++ bool System.Collections.IList.Contains(object value); ++ int System.Collections.IList.IndexOf(object value); ++ void System.Collections.IList.Insert(int index, object value); ++ void System.Collections.IList.Remove(object value); ++ void System.Collections.IList.RemoveAt(int index); ++ public struct Enumerator : IDisposable, IEnumerator, IEnumerator<TKey> { ++ public TKey Current { get; } ++ object System.Collections.IEnumerator.Current { get; } ++ public bool MoveNext(); ++ void System.Collections.IEnumerator.Reset(); ++ void System.IDisposable.Dispose(); ++ } ++ } ++ public sealed class ValueCollection : ICollection, ICollection<TValue>, IEnumerable, IEnumerable<TValue>, IList, IList<TValue>, IReadOnlyCollection<TValue>, IReadOnlyList<TValue> { ++ public int Count { get; } ++ bool ICollection<TValue>.IsReadOnly { get; } ++ TValue IList<TValue>.this[int index] { get; set; } ++ TValue IReadOnlyList<TValue>.this[int index] { get; } ++ bool System.Collections.ICollection.IsSynchronized { get; } ++ object System.Collections.ICollection.SyncRoot { get; } ++ bool System.Collections.IList.IsFixedSize { get; } ++ bool System.Collections.IList.IsReadOnly { get; } ++ object? System.Collections.IList.this[int index] { get; set; } ++ public void CopyTo(TValue[] array, int arrayIndex); ++ public OrderedDictionary<TKey, TValue>.ValueCollection.Enumerator GetEnumerator(); ++ void ICollection<TValue>.Add(TValue item); ++ void ICollection<TValue>.Clear(); ++ bool ICollection<TValue>.Contains(TValue item); ++ bool ICollection<TValue>.Remove(TValue item); ++ IEnumerator<TValue> IEnumerable<TValue>.GetEnumerator(); ++ int IList<TValue>.IndexOf(TValue item); ++ void IList<TValue>.Insert(int index, TValue item); ++ void IList<TValue>.RemoveAt(int index); ++ void System.Collections.ICollection.CopyTo(Array array, int index); ++ IEnumerator System.Collections.IEnumerable.GetEnumerator(); ++ int System.Collections.IList.Add(object value); ++ void System.Collections.IList.Clear(); ++ bool System.Collections.IList.Contains(object value); ++ int System.Collections.IList.IndexOf(object value); ++ void System.Collections.IList.Insert(int index, object value); ++ void System.Collections.IList.Remove(object value); ++ void System.Collections.IList.RemoveAt(int index); ++ public struct Enumerator : IDisposable, IEnumerator, IEnumerator<TValue> { ++ public TValue Current { get; } ++ object? System.Collections.IEnumerator.Current { get; } ++ public bool MoveNext(); ++ void System.Collections.IEnumerator.Reset(); ++ void System.IDisposable.Dispose(); ++ } ++ } ++ } + } +``` + diff --git a/release-notes/9.0/preview/preview6/api-diff/Microsoft.NETCore.App/9.0-preview6_System.Collections.ObjectModel.md b/release-notes/9.0/preview/preview6/api-diff/Microsoft.NETCore.App/9.0-preview6_System.Collections.ObjectModel.md new file mode 100644 index 0000000000..bf544ade42 --- /dev/null +++ b/release-notes/9.0/preview/preview6/api-diff/Microsoft.NETCore.App/9.0-preview6_System.Collections.ObjectModel.md @@ -0,0 +1,35 @@ +# System.Collections.ObjectModel + +``` diff + namespace System.Collections.ObjectModel { ++ public class ReadOnlySet<T> : ICollection, ICollection<T>, IEnumerable, IEnumerable<T>, IReadOnlyCollection<T>, IReadOnlySet<T>, ISet<T> { ++ public ReadOnlySet(ISet<T> @set); ++ public int Count { get; } ++ public static ReadOnlySet<T> Empty { get; } ++ protected ISet<T> Set { get; } ++ bool ICollection<T>.IsReadOnly { get; } ++ bool ICollection.IsSynchronized { get; } ++ object ICollection.SyncRoot { get; } ++ public bool Contains(T item); ++ public IEnumerator<T> GetEnumerator(); ++ public bool IsProperSubsetOf(IEnumerable<T> other); ++ public bool IsProperSupersetOf(IEnumerable<T> other); ++ public bool IsSubsetOf(IEnumerable<T> other); ++ public bool IsSupersetOf(IEnumerable<T> other); ++ public bool Overlaps(IEnumerable<T> other); ++ public bool SetEquals(IEnumerable<T> other); ++ void ICollection<T>.Add(T item); ++ void ICollection<T>.Clear(); ++ void ICollection<T>.CopyTo(T[] array, int arrayIndex); ++ bool ICollection<T>.Remove(T item); ++ bool ISet<T>.Add(T item); ++ void ISet<T>.ExceptWith(IEnumerable<T> other); ++ void ISet<T>.IntersectWith(IEnumerable<T> other); ++ void ISet<T>.SymmetricExceptWith(IEnumerable<T> other); ++ void ISet<T>.UnionWith(IEnumerable<T> other); ++ void ICollection.CopyTo(Array array, int index); ++ IEnumerator IEnumerable.GetEnumerator(); ++ } + } +``` + diff --git a/release-notes/9.0/preview/preview6/api-diff/Microsoft.NETCore.App/9.0-preview6_System.Diagnostics.Metrics.md b/release-notes/9.0/preview/preview6/api-diff/Microsoft.NETCore.App/9.0-preview6_System.Diagnostics.Metrics.md new file mode 100644 index 0000000000..3710f38ae1 --- /dev/null +++ b/release-notes/9.0/preview/preview6/api-diff/Microsoft.NETCore.App/9.0-preview6_System.Diagnostics.Metrics.md @@ -0,0 +1,40 @@ +# System.Diagnostics.Metrics + +``` diff + namespace System.Diagnostics.Metrics { ++ public sealed class Gauge<T> : Instrument<T> where T : struct { ++ public void Record(T value); ++ public void Record(T value, KeyValuePair<string, object?> tag); ++ public void Record(T value, KeyValuePair<string, object?> tag1, KeyValuePair<string, object?> tag2); ++ public void Record(T value, KeyValuePair<string, object?> tag1, KeyValuePair<string, object?> tag2, KeyValuePair<string, object?> tag3); ++ public void Record(T value, params KeyValuePair<string, object>[] tags); ++ public void Record(T value, in TagList tagList); ++ public void Record(T value, ReadOnlySpan<KeyValuePair<string, object?>> tags); ++ } + public abstract class Instrument { ++ protected Instrument(Meter meter, string name); +- protected Instrument(Meter meter, string name, string? unit, string? description, IEnumerable<KeyValuePair<string, object?>>? tags); ++ protected Instrument(Meter meter, string name, string? unit = null, string? description = null, IEnumerable<KeyValuePair<string, object?>>? tags = null); + } + public abstract class Instrument<T> : Instrument where T : struct { ++ protected Instrument(Meter meter, string name); ++ protected Instrument(Meter meter, string name, string? unit = null, string? description = null, IEnumerable<KeyValuePair<string, object?>>? tags = null, InstrumentAdvice<T>? advice = null); ++ public InstrumentAdvice<T>? Advice { get; } + } ++ public sealed class InstrumentAdvice<T> where T : struct { ++ public InstrumentAdvice(); ++ public IReadOnlyList<T>? HistogramBucketBoundaries { get; set; } ++ } + public class Meter : IDisposable { ++ public Gauge<T> CreateGauge<T>(string name) where T : struct; ++ public Gauge<T> CreateGauge<T>(string name, string unit = null, string description = null, IEnumerable<KeyValuePair<string, object?>>? tags = null) where T : struct; ++ public Histogram<T> CreateHistogram<T>(string name) where T : struct; +- public Histogram<T> CreateHistogram<T>(string name, string unit = null, string description = null) where T : struct; ++ public Histogram<T> CreateHistogram<T>(string name, string unit, string description) where T : struct; +- public Histogram<T> CreateHistogram<T>(string name, string unit, string description, IEnumerable<KeyValuePair<string, object?>> tags) where T : struct; ++ public Histogram<T> CreateHistogram<T>(string name, string unit, string description, IEnumerable<KeyValuePair<string, object?>>? tags) where T : struct; ++ public Histogram<T> CreateHistogram<T>(string name, string unit = null, string description = null, IEnumerable<KeyValuePair<string, object?>>? tags = null, InstrumentAdvice<T>? advice = null) where T : struct; + } + } +``` + diff --git a/release-notes/9.0/preview/preview6/api-diff/Microsoft.NETCore.App/9.0-preview6_System.Diagnostics.md b/release-notes/9.0/preview/preview6/api-diff/Microsoft.NETCore.App/9.0-preview6_System.Diagnostics.md new file mode 100644 index 0000000000..01222799f4 --- /dev/null +++ b/release-notes/9.0/preview/preview6/api-diff/Microsoft.NETCore.App/9.0-preview6_System.Diagnostics.md @@ -0,0 +1,26 @@ +# System.Diagnostics + +``` diff + namespace System.Diagnostics { + public class Activity : IDisposable { ++ public Activity AddException(Exception exception, in TagList tags = default(TagList), DateTimeOffset timestamp = default(DateTimeOffset)); + } + public sealed class ActivityListener : IDisposable { ++ public ExceptionRecorder ExceptionRecorder { get; set; } + } + public sealed class ActivitySource : IDisposable { ++ public ActivitySource(string name); ++ public ActivitySource(string name, string? version = "", IEnumerable<KeyValuePair<string, object?>>? tags = null); ++ public IEnumerable<KeyValuePair<string, object?>>? Tags { get; } + } ++ public sealed class DiagnosticMethodInfo { ++ public string DeclaringAssemblyName { get; } ++ public string DeclaringTypeName { get; } ++ public string Name { get; } ++ public static DiagnosticMethodInfo? Create(Delegate @delegate); ++ public static DiagnosticMethodInfo? Create(StackFrame frame); ++ } ++ public delegate void ExceptionRecorder(Activity activity, Exception exception, ref TagList tags); + } +``` + diff --git a/release-notes/9.0/preview/preview6/api-diff/Microsoft.NETCore.App/9.0-preview6_System.IO.md b/release-notes/9.0/preview/preview6/api-diff/Microsoft.NETCore.App/9.0-preview6_System.IO.md new file mode 100644 index 0000000000..f6da1cf817 --- /dev/null +++ b/release-notes/9.0/preview/preview6/api-diff/Microsoft.NETCore.App/9.0-preview6_System.IO.md @@ -0,0 +1,21 @@ +# System.IO + +``` diff + namespace System.IO { + public static class File { ++ public static void AppendAllBytes(string path, ReadOnlySpan<byte> bytes); ++ public static Task AppendAllBytesAsync(string path, ReadOnlyMemory<byte> bytes, CancellationToken cancellationToken = default(CancellationToken)); ++ public static void AppendAllText(string path, ReadOnlySpan<char> contents); ++ public static void AppendAllText(string path, ReadOnlySpan<char> contents, Encoding encoding); ++ public static Task AppendAllTextAsync(string path, ReadOnlyMemory<char> contents, Encoding encoding, CancellationToken cancellationToken = default(CancellationToken)); ++ public static Task AppendAllTextAsync(string path, ReadOnlyMemory<char> contents, CancellationToken cancellationToken = default(CancellationToken)); ++ public static void WriteAllBytes(string path, ReadOnlySpan<byte> bytes); ++ public static Task WriteAllBytesAsync(string path, ReadOnlyMemory<byte> bytes, CancellationToken cancellationToken = default(CancellationToken)); ++ public static void WriteAllText(string path, ReadOnlySpan<char> contents); ++ public static void WriteAllText(string path, ReadOnlySpan<char> contents, Encoding encoding); ++ public static Task WriteAllTextAsync(string path, ReadOnlyMemory<char> contents, Encoding encoding, CancellationToken cancellationToken = default(CancellationToken)); ++ public static Task WriteAllTextAsync(string path, ReadOnlyMemory<char> contents, CancellationToken cancellationToken = default(CancellationToken)); + } + } +``` + diff --git a/release-notes/9.0/preview/preview6/api-diff/Microsoft.NETCore.App/9.0-preview6_System.Net.Http.md b/release-notes/9.0/preview/preview6/api-diff/Microsoft.NETCore.App/9.0-preview6_System.Net.Http.md new file mode 100644 index 0000000000..d69f5a7718 --- /dev/null +++ b/release-notes/9.0/preview/preview6/api-diff/Microsoft.NETCore.App/9.0-preview6_System.Net.Http.md @@ -0,0 +1,15 @@ +# System.Net.Http + +``` diff + namespace System.Net.Http { + public class StringContent : ByteArrayContent { +- public StringContent(string content, MediaTypeHeaderValue mediaType); ++ public StringContent(string content, MediaTypeHeaderValue? mediaType); +- public StringContent(string content, Encoding? encoding, MediaTypeHeaderValue mediaType); ++ public StringContent(string content, Encoding? encoding, MediaTypeHeaderValue? mediaType); +- public StringContent(string content, Encoding? encoding, string mediaType); ++ public StringContent(string content, Encoding? encoding, string? mediaType); + } + } +``` + diff --git a/release-notes/9.0/preview/preview6/api-diff/Microsoft.NETCore.App/9.0-preview6_System.Net.Mime.md b/release-notes/9.0/preview/preview6/api-diff/Microsoft.NETCore.App/9.0-preview6_System.Net.Mime.md new file mode 100644 index 0000000000..3984aa2032 --- /dev/null +++ b/release-notes/9.0/preview/preview6/api-diff/Microsoft.NETCore.App/9.0-preview6_System.Net.Mime.md @@ -0,0 +1,19 @@ +# System.Net.Mime + +``` diff + namespace System.Net.Mime { + public static class MediaTypeNames { + public static class Application { ++ public const string GZip = "application/gzip"; + } + public static class Multipart { ++ public const string Mixed = "multipart/mixed"; ++ public const string Related = "multipart/related"; + } + public static class Text { ++ public const string EventStream = "text/event-stream"; + } + } + } +``` + diff --git a/release-notes/9.0/preview/preview6/api-diff/Microsoft.NETCore.App/9.0-preview6_System.Net.Sockets.md b/release-notes/9.0/preview/preview6/api-diff/Microsoft.NETCore.App/9.0-preview6_System.Net.Sockets.md new file mode 100644 index 0000000000..0cf49bec07 --- /dev/null +++ b/release-notes/9.0/preview/preview6/api-diff/Microsoft.NETCore.App/9.0-preview6_System.Net.Sockets.md @@ -0,0 +1,10 @@ +# System.Net.Sockets + +``` diff + namespace System.Net.Sockets { + public enum SocketOptionName { ++ FastOpen = 15, + } + } +``` + diff --git a/release-notes/9.0/preview/preview6/api-diff/Microsoft.NETCore.App/9.0-preview6_System.Numerics.md b/release-notes/9.0/preview/preview6/api-diff/Microsoft.NETCore.App/9.0-preview6_System.Numerics.md new file mode 100644 index 0000000000..59d277c248 --- /dev/null +++ b/release-notes/9.0/preview/preview6/api-diff/Microsoft.NETCore.App/9.0-preview6_System.Numerics.md @@ -0,0 +1,39 @@ +# System.Numerics + +``` diff + namespace System.Numerics { + public static class Vector { ++ public static Plane AsPlane(this Vector4 value); ++ public static Quaternion AsQuaternion(this Vector4 value); ++ public static Vector2 AsVector2(this Vector4 value); ++ public static Vector3 AsVector3(this Vector4 value); ++ public static Vector4 AsVector4(this Plane value); ++ public static Vector4 AsVector4(this Quaternion value); ++ public static Vector4 AsVector4(this Vector2 value); ++ public static Vector4 AsVector4(this Vector3 value); ++ public static Vector4 AsVector4Unsafe(this Vector2 value); ++ public static Vector4 AsVector4Unsafe(this Vector3 value); ++ public static Vector<T> Create<T>(ReadOnlySpan<T> values); ++ public static Vector<T> Create<T>(T value); + } + public struct Vector2 : IEquatable<Vector2>, IFormattable { ++ public static Vector2 Create(ReadOnlySpan<float> values); ++ public static Vector2 Create(float value); ++ public static Vector2 Create(float x, float y); + } + public struct Vector3 : IEquatable<Vector3>, IFormattable { ++ public static Vector3 Create(Vector2 vector, float z); ++ public static Vector3 Create(ReadOnlySpan<float> values); ++ public static Vector3 Create(float value); ++ public static Vector3 Create(float x, float y, float z); + } + public struct Vector4 : IEquatable<Vector4>, IFormattable { ++ public static Vector4 Create(Vector2 vector, float z, float w); ++ public static Vector4 Create(Vector3 vector, float w); ++ public static Vector4 Create(ReadOnlySpan<float> values); ++ public static Vector4 Create(float value); ++ public static Vector4 Create(float x, float y, float z, float w); + } + } +``` + diff --git a/release-notes/9.0/preview/preview6/api-diff/Microsoft.NETCore.App/9.0-preview6_System.Reflection.Emit.md b/release-notes/9.0/preview/preview6/api-diff/Microsoft.NETCore.App/9.0-preview6_System.Reflection.Emit.md new file mode 100644 index 0000000000..d7b746d1f4 --- /dev/null +++ b/release-notes/9.0/preview/preview6/api-diff/Microsoft.NETCore.App/9.0-preview6_System.Reflection.Emit.md @@ -0,0 +1,11 @@ +# System.Reflection.Emit + +``` diff + namespace System.Reflection.Emit { + public abstract class GenericTypeParameterBuilder : TypeInfo { +- public override Type GetElementType(); ++ public override Type? GetElementType(); + } + } +``` + diff --git a/release-notes/9.0/preview/preview6/api-diff/Microsoft.NETCore.App/9.0-preview6_System.Runtime.InteropServices.Marshalling.md b/release-notes/9.0/preview/preview6/api-diff/Microsoft.NETCore.App/9.0-preview6_System.Runtime.InteropServices.Marshalling.md new file mode 100644 index 0000000000..2df7a2ed89 --- /dev/null +++ b/release-notes/9.0/preview/preview6/api-diff/Microsoft.NETCore.App/9.0-preview6_System.Runtime.InteropServices.Marshalling.md @@ -0,0 +1,16 @@ +# System.Runtime.InteropServices.Marshalling + +``` diff + namespace System.Runtime.InteropServices.Marshalling { + public static class ReadOnlySpanMarshaller<T, TUnmanagedElement> where TUnmanagedElement : struct { ++ public struct ManagedToUnmanagedOut { ++ public void Free(); ++ public unsafe void FromUnmanaged(TUnmanagedElement* unmanaged); ++ public Span<T> GetManagedValuesDestination(int numElements); ++ public ReadOnlySpan<TUnmanagedElement> GetUnmanagedValuesSource(int numElements); ++ public ReadOnlySpan<T> ToManaged(); ++ } + } + } +``` + diff --git a/release-notes/9.0/preview/preview6/api-diff/Microsoft.NETCore.App/9.0-preview6_System.Runtime.InteropServices.Swift.md b/release-notes/9.0/preview/preview6/api-diff/Microsoft.NETCore.App/9.0-preview6_System.Runtime.InteropServices.Swift.md new file mode 100644 index 0000000000..6d02f09a3c --- /dev/null +++ b/release-notes/9.0/preview/preview6/api-diff/Microsoft.NETCore.App/9.0-preview6_System.Runtime.InteropServices.Swift.md @@ -0,0 +1,15 @@ +# System.Runtime.InteropServices.Swift + +``` diff + namespace System.Runtime.InteropServices.Swift { ++ public readonly struct SwiftIndirectResult { ++ public unsafe SwiftIndirectResult(void* value); ++ public unsafe void* Value { get; } ++ } ++ public readonly struct SwiftSelf<T> where T : struct { ++ public SwiftSelf(T value); ++ public T Value { get; } ++ } + } +``` + diff --git a/release-notes/9.0/preview/preview6/api-diff/Microsoft.NETCore.App/9.0-preview6_System.Runtime.InteropServices.md b/release-notes/9.0/preview/preview6/api-diff/Microsoft.NETCore.App/9.0-preview6_System.Runtime.InteropServices.md new file mode 100644 index 0000000000..7b9d23f41a --- /dev/null +++ b/release-notes/9.0/preview/preview6/api-diff/Microsoft.NETCore.App/9.0-preview6_System.Runtime.InteropServices.md @@ -0,0 +1,11 @@ +# System.Runtime.InteropServices + +``` diff + namespace System.Runtime.InteropServices { + public static class CollectionsMarshal { ++ public static ref TValue? GetValueRefOrAddDefault<TKey, TValue, TAlternateKey>(Dictionary.AlternateLookup<TAlternateKey> dictionary, TAlternateKey key, out bool exists); ++ public static ref TValue GetValueRefOrNullRef<TKey, TValue, TAlternateKey>(Dictionary.AlternateLookup<TAlternateKey> dictionary, TAlternateKey key); + } + } +``` + diff --git a/release-notes/9.0/preview/preview6/api-diff/Microsoft.NETCore.App/9.0-preview6_System.Runtime.Intrinsics.Arm.md b/release-notes/9.0/preview/preview6/api-diff/Microsoft.NETCore.App/9.0-preview6_System.Runtime.Intrinsics.Arm.md new file mode 100644 index 0000000000..88e375970c --- /dev/null +++ b/release-notes/9.0/preview/preview6/api-diff/Microsoft.NETCore.App/9.0-preview6_System.Runtime.Intrinsics.Arm.md @@ -0,0 +1,1058 @@ +# System.Runtime.Intrinsics.Arm + +``` diff + namespace System.Runtime.Intrinsics.Arm { + public abstract class AdvSimd : ArmBase { ++ public unsafe static (Vector64<byte> Value1, Vector64<byte> Value2) Load2xVector64(byte* address); ++ public unsafe static (Vector64<short> Value1, Vector64<short> Value2) Load2xVector64(short* address); ++ public unsafe static (Vector64<int> Value1, Vector64<int> Value2) Load2xVector64(int* address); ++ public unsafe static (Vector64<sbyte> Value1, Vector64<sbyte> Value2) Load2xVector64(sbyte* address); ++ public unsafe static (Vector64<float> Value1, Vector64<float> Value2) Load2xVector64(float* address); ++ public unsafe static (Vector64<ushort> Value1, Vector64<ushort> Value2) Load2xVector64(ushort* address); ++ public unsafe static (Vector64<uint> Value1, Vector64<uint> Value2) Load2xVector64(uint* address); ++ public unsafe static (Vector64<byte> Value1, Vector64<byte> Value2) Load2xVector64AndUnzip(byte* address); ++ public unsafe static (Vector64<short> Value1, Vector64<short> Value2) Load2xVector64AndUnzip(short* address); ++ public unsafe static (Vector64<int> Value1, Vector64<int> Value2) Load2xVector64AndUnzip(int* address); ++ public unsafe static (Vector64<sbyte> Value1, Vector64<sbyte> Value2) Load2xVector64AndUnzip(sbyte* address); ++ public unsafe static (Vector64<float> Value1, Vector64<float> Value2) Load2xVector64AndUnzip(float* address); ++ public unsafe static (Vector64<ushort> Value1, Vector64<ushort> Value2) Load2xVector64AndUnzip(ushort* address); ++ public unsafe static (Vector64<uint> Value1, Vector64<uint> Value2) Load2xVector64AndUnzip(uint* address); ++ public unsafe static (Vector64<byte> Value1, Vector64<byte> Value2, Vector64<byte> Value3) Load3xVector64(byte* address); ++ public unsafe static (Vector64<short> Value1, Vector64<short> Value2, Vector64<short> Value3) Load3xVector64(short* address); ++ public unsafe static (Vector64<int> Value1, Vector64<int> Value2, Vector64<int> Value3) Load3xVector64(int* address); ++ public unsafe static (Vector64<sbyte> Value1, Vector64<sbyte> Value2, Vector64<sbyte> Value3) Load3xVector64(sbyte* address); ++ public unsafe static (Vector64<float> Value1, Vector64<float> Value2, Vector64<float> Value3) Load3xVector64(float* address); ++ public unsafe static (Vector64<ushort> Value1, Vector64<ushort> Value2, Vector64<ushort> Value3) Load3xVector64(ushort* address); ++ public unsafe static (Vector64<uint> Value1, Vector64<uint> Value2, Vector64<uint> Value3) Load3xVector64(uint* address); ++ public unsafe static (Vector64<byte> Value1, Vector64<byte> Value2, Vector64<byte> Value3) Load3xVector64AndUnzip(byte* address); ++ public unsafe static (Vector64<short> Value1, Vector64<short> Value2, Vector64<short> Value3) Load3xVector64AndUnzip(short* address); ++ public unsafe static (Vector64<int> Value1, Vector64<int> Value2, Vector64<int> Value3) Load3xVector64AndUnzip(int* address); ++ public unsafe static (Vector64<sbyte> Value1, Vector64<sbyte> Value2, Vector64<sbyte> Value3) Load3xVector64AndUnzip(sbyte* address); ++ public unsafe static (Vector64<float> Value1, Vector64<float> Value2, Vector64<float> Value3) Load3xVector64AndUnzip(float* address); ++ public unsafe static (Vector64<ushort> Value1, Vector64<ushort> Value2, Vector64<ushort> Value3) Load3xVector64AndUnzip(ushort* address); ++ public unsafe static (Vector64<uint> Value1, Vector64<uint> Value2, Vector64<uint> Value3) Load3xVector64AndUnzip(uint* address); ++ public unsafe static (Vector64<byte> Value1, Vector64<byte> Value2, Vector64<byte> Value3, Vector64<byte> Value4) Load4xVector64(byte* address); ++ public unsafe static (Vector64<short> Value1, Vector64<short> Value2, Vector64<short> Value3, Vector64<short> Value4) Load4xVector64(short* address); ++ public unsafe static (Vector64<int> Value1, Vector64<int> Value2, Vector64<int> Value3, Vector64<int> Value4) Load4xVector64(int* address); ++ public unsafe static (Vector64<sbyte> Value1, Vector64<sbyte> Value2, Vector64<sbyte> Value3, Vector64<sbyte> Value4) Load4xVector64(sbyte* address); ++ public unsafe static (Vector64<float> Value1, Vector64<float> Value2, Vector64<float> Value3, Vector64<float> Value4) Load4xVector64(float* address); ++ public unsafe static (Vector64<ushort> Value1, Vector64<ushort> Value2, Vector64<ushort> Value3, Vector64<ushort> Value4) Load4xVector64(ushort* address); ++ public unsafe static (Vector64<uint> Value1, Vector64<uint> Value2, Vector64<uint> Value3, Vector64<uint> Value4) Load4xVector64(uint* address); ++ public unsafe static (Vector64<byte> Value1, Vector64<byte> Value2, Vector64<byte> Value3, Vector64<byte> Value4) Load4xVector64AndUnzip(byte* address); ++ public unsafe static (Vector64<short> Value1, Vector64<short> Value2, Vector64<short> Value3, Vector64<short> Value4) Load4xVector64AndUnzip(short* address); ++ public unsafe static (Vector64<int> Value1, Vector64<int> Value2, Vector64<int> Value3, Vector64<int> Value4) Load4xVector64AndUnzip(int* address); ++ public unsafe static (Vector64<sbyte> Value1, Vector64<sbyte> Value2, Vector64<sbyte> Value3, Vector64<sbyte> Value4) Load4xVector64AndUnzip(sbyte* address); ++ public unsafe static (Vector64<float> Value1, Vector64<float> Value2, Vector64<float> Value3, Vector64<float> Value4) Load4xVector64AndUnzip(float* address); ++ public unsafe static (Vector64<ushort> Value1, Vector64<ushort> Value2, Vector64<ushort> Value3, Vector64<ushort> Value4) Load4xVector64AndUnzip(ushort* address); ++ public unsafe static (Vector64<uint> Value1, Vector64<uint> Value2, Vector64<uint> Value3, Vector64<uint> Value4) Load4xVector64AndUnzip(uint* address); +- public unsafe static (Vector64<byte> Value1, Vector64<byte> Value2) LoadVector64x2(byte* address); + +- public unsafe static (Vector64<short> Value1, Vector64<short> Value2) LoadVector64x2(short* address); + +- public unsafe static (Vector64<int> Value1, Vector64<int> Value2) LoadVector64x2(int* address); + +- public unsafe static (Vector64<sbyte> Value1, Vector64<sbyte> Value2) LoadVector64x2(sbyte* address); + +- public unsafe static (Vector64<float> Value1, Vector64<float> Value2) LoadVector64x2(float* address); + +- public unsafe static (Vector64<ushort> Value1, Vector64<ushort> Value2) LoadVector64x2(ushort* address); + +- public unsafe static (Vector64<uint> Value1, Vector64<uint> Value2) LoadVector64x2(uint* address); + +- public unsafe static (Vector64<byte> Value1, Vector64<byte> Value2) LoadVector64x2AndUnzip(byte* address); + +- public unsafe static (Vector64<short> Value1, Vector64<short> Value2) LoadVector64x2AndUnzip(short* address); + +- public unsafe static (Vector64<int> Value1, Vector64<int> Value2) LoadVector64x2AndUnzip(int* address); + +- public unsafe static (Vector64<sbyte> Value1, Vector64<sbyte> Value2) LoadVector64x2AndUnzip(sbyte* address); + +- public unsafe static (Vector64<float> Value1, Vector64<float> Value2) LoadVector64x2AndUnzip(float* address); + +- public unsafe static (Vector64<ushort> Value1, Vector64<ushort> Value2) LoadVector64x2AndUnzip(ushort* address); + +- public unsafe static (Vector64<uint> Value1, Vector64<uint> Value2) LoadVector64x2AndUnzip(uint* address); + +- public unsafe static (Vector64<byte> Value1, Vector64<byte> Value2, Vector64<byte> Value3) LoadVector64x3(byte* address); + +- public unsafe static (Vector64<short> Value1, Vector64<short> Value2, Vector64<short> Value3) LoadVector64x3(short* address); + +- public unsafe static (Vector64<int> Value1, Vector64<int> Value2, Vector64<int> Value3) LoadVector64x3(int* address); + +- public unsafe static (Vector64<sbyte> Value1, Vector64<sbyte> Value2, Vector64<sbyte> Value3) LoadVector64x3(sbyte* address); + +- public unsafe static (Vector64<float> Value1, Vector64<float> Value2, Vector64<float> Value3) LoadVector64x3(float* address); + +- public unsafe static (Vector64<ushort> Value1, Vector64<ushort> Value2, Vector64<ushort> Value3) LoadVector64x3(ushort* address); + +- public unsafe static (Vector64<uint> Value1, Vector64<uint> Value2, Vector64<uint> Value3) LoadVector64x3(uint* address); + +- public unsafe static (Vector64<byte> Value1, Vector64<byte> Value2, Vector64<byte> Value3) LoadVector64x3AndUnzip(byte* address); + +- public unsafe static (Vector64<short> Value1, Vector64<short> Value2, Vector64<short> Value3) LoadVector64x3AndUnzip(short* address); + +- public unsafe static (Vector64<int> Value1, Vector64<int> Value2, Vector64<int> Value3) LoadVector64x3AndUnzip(int* address); + +- public unsafe static (Vector64<sbyte> Value1, Vector64<sbyte> Value2, Vector64<sbyte> Value3) LoadVector64x3AndUnzip(sbyte* address); + +- public unsafe static (Vector64<float> Value1, Vector64<float> Value2, Vector64<float> Value3) LoadVector64x3AndUnzip(float* address); + +- public unsafe static (Vector64<ushort> Value1, Vector64<ushort> Value2, Vector64<ushort> Value3) LoadVector64x3AndUnzip(ushort* address); + +- public unsafe static (Vector64<uint> Value1, Vector64<uint> Value2, Vector64<uint> Value3) LoadVector64x3AndUnzip(uint* address); + +- public unsafe static (Vector64<byte> Value1, Vector64<byte> Value2, Vector64<byte> Value3, Vector64<byte> Value4) LoadVector64x4(byte* address); + +- public unsafe static (Vector64<short> Value1, Vector64<short> Value2, Vector64<short> Value3, Vector64<short> Value4) LoadVector64x4(short* address); + +- public unsafe static (Vector64<int> Value1, Vector64<int> Value2, Vector64<int> Value3, Vector64<int> Value4) LoadVector64x4(int* address); + +- public unsafe static (Vector64<sbyte> Value1, Vector64<sbyte> Value2, Vector64<sbyte> Value3, Vector64<sbyte> Value4) LoadVector64x4(sbyte* address); + +- public unsafe static (Vector64<float> Value1, Vector64<float> Value2, Vector64<float> Value3, Vector64<float> Value4) LoadVector64x4(float* address); + +- public unsafe static (Vector64<ushort> Value1, Vector64<ushort> Value2, Vector64<ushort> Value3, Vector64<ushort> Value4) LoadVector64x4(ushort* address); + +- public unsafe static (Vector64<uint> Value1, Vector64<uint> Value2, Vector64<uint> Value3, Vector64<uint> Value4) LoadVector64x4(uint* address); + +- public unsafe static (Vector64<byte> Value1, Vector64<byte> Value2, Vector64<byte> Value3, Vector64<byte> Value4) LoadVector64x4AndUnzip(byte* address); + +- public unsafe static (Vector64<short> Value1, Vector64<short> Value2, Vector64<short> Value3, Vector64<short> Value4) LoadVector64x4AndUnzip(short* address); + +- public unsafe static (Vector64<int> Value1, Vector64<int> Value2, Vector64<int> Value3, Vector64<int> Value4) LoadVector64x4AndUnzip(int* address); + +- public unsafe static (Vector64<sbyte> Value1, Vector64<sbyte> Value2, Vector64<sbyte> Value3, Vector64<sbyte> Value4) LoadVector64x4AndUnzip(sbyte* address); + +- public unsafe static (Vector64<float> Value1, Vector64<float> Value2, Vector64<float> Value3, Vector64<float> Value4) LoadVector64x4AndUnzip(float* address); + +- public unsafe static (Vector64<ushort> Value1, Vector64<ushort> Value2, Vector64<ushort> Value3, Vector64<ushort> Value4) LoadVector64x4AndUnzip(ushort* address); + +- public unsafe static (Vector64<uint> Value1, Vector64<uint> Value2, Vector64<uint> Value3, Vector64<uint> Value4) LoadVector64x4AndUnzip(uint* address); + ++ public unsafe static void Store(byte* address, (Vector64<byte> Value1, Vector64<byte> Value2, Vector64<byte> Value3, Vector64<byte> Value4) value); ++ public unsafe static void Store(byte* address, (Vector64<byte> Value1, Vector64<byte> Value2, Vector64<byte> Value3) value); ++ public unsafe static void Store(byte* address, (Vector64<byte> Value1, Vector64<byte> Value2) value); ++ public unsafe static void Store(short* address, (Vector64<short> Value1, Vector64<short> Value2, Vector64<short> Value3, Vector64<short> Value4) value); ++ public unsafe static void Store(short* address, (Vector64<short> Value1, Vector64<short> Value2, Vector64<short> Value3) value); ++ public unsafe static void Store(short* address, (Vector64<short> Value1, Vector64<short> Value2) value); ++ public unsafe static void Store(int* address, (Vector64<int> Value1, Vector64<int> Value2, Vector64<int> Value3, Vector64<int> Value4) value); ++ public unsafe static void Store(int* address, (Vector64<int> Value1, Vector64<int> Value2, Vector64<int> Value3) value); ++ public unsafe static void Store(int* address, (Vector64<int> Value1, Vector64<int> Value2) value); ++ public unsafe static void Store(sbyte* address, (Vector64<sbyte> Value1, Vector64<sbyte> Value2, Vector64<sbyte> Value3, Vector64<sbyte> Value4) value); ++ public unsafe static void Store(sbyte* address, (Vector64<sbyte> Value1, Vector64<sbyte> Value2, Vector64<sbyte> Value3) value); ++ public unsafe static void Store(sbyte* address, (Vector64<sbyte> Value1, Vector64<sbyte> Value2) value); ++ public unsafe static void Store(float* address, (Vector64<float> Value1, Vector64<float> Value2, Vector64<float> Value3, Vector64<float> Value4) value); ++ public unsafe static void Store(float* address, (Vector64<float> Value1, Vector64<float> Value2, Vector64<float> Value3) value); ++ public unsafe static void Store(float* address, (Vector64<float> Value1, Vector64<float> Value2) value); ++ public unsafe static void Store(ushort* address, (Vector64<ushort> Value1, Vector64<ushort> Value2, Vector64<ushort> Value3, Vector64<ushort> Value4) value); ++ public unsafe static void Store(ushort* address, (Vector64<ushort> Value1, Vector64<ushort> Value2, Vector64<ushort> Value3) value); ++ public unsafe static void Store(ushort* address, (Vector64<ushort> Value1, Vector64<ushort> Value2) value); ++ public unsafe static void Store(uint* address, (Vector64<uint> Value1, Vector64<uint> Value2, Vector64<uint> Value3, Vector64<uint> Value4) value); ++ public unsafe static void Store(uint* address, (Vector64<uint> Value1, Vector64<uint> Value2, Vector64<uint> Value3) value); ++ public unsafe static void Store(uint* address, (Vector64<uint> Value1, Vector64<uint> Value2) value); +- public unsafe static void StoreVector64x2(byte* address, (Vector64<byte> Value1, Vector64<byte> Value2) value); + +- public unsafe static void StoreVector64x2(short* address, (Vector64<short> Value1, Vector64<short> Value2) value); + +- public unsafe static void StoreVector64x2(int* address, (Vector64<int> Value1, Vector64<int> Value2) value); + +- public unsafe static void StoreVector64x2(sbyte* address, (Vector64<sbyte> Value1, Vector64<sbyte> Value2) value); + +- public unsafe static void StoreVector64x2(float* address, (Vector64<float> Value1, Vector64<float> Value2) value); + +- public unsafe static void StoreVector64x2(ushort* address, (Vector64<ushort> Value1, Vector64<ushort> Value2) value); + +- public unsafe static void StoreVector64x2(uint* address, (Vector64<uint> Value1, Vector64<uint> Value2) value); + +- public unsafe static void StoreVector64x2AndZip(byte* address, (Vector64<byte> Value1, Vector64<byte> Value2) value); + +- public unsafe static void StoreVector64x2AndZip(short* address, (Vector64<short> Value1, Vector64<short> Value2) value); + +- public unsafe static void StoreVector64x2AndZip(int* address, (Vector64<int> Value1, Vector64<int> Value2) value); + +- public unsafe static void StoreVector64x2AndZip(sbyte* address, (Vector64<sbyte> Value1, Vector64<sbyte> Value2) value); + +- public unsafe static void StoreVector64x2AndZip(float* address, (Vector64<float> Value1, Vector64<float> Value2) value); + +- public unsafe static void StoreVector64x2AndZip(ushort* address, (Vector64<ushort> Value1, Vector64<ushort> Value2) value); + +- public unsafe static void StoreVector64x2AndZip(uint* address, (Vector64<uint> Value1, Vector64<uint> Value2) value); + +- public unsafe static void StoreVector64x3(byte* address, (Vector64<byte> Value1, Vector64<byte> Value2, Vector64<byte> Value3) value); + +- public unsafe static void StoreVector64x3(short* address, (Vector64<short> Value1, Vector64<short> Value2, Vector64<short> Value3) value); + +- public unsafe static void StoreVector64x3(int* address, (Vector64<int> Value1, Vector64<int> Value2, Vector64<int> Value3) value); + +- public unsafe static void StoreVector64x3(sbyte* address, (Vector64<sbyte> Value1, Vector64<sbyte> Value2, Vector64<sbyte> Value3) value); + +- public unsafe static void StoreVector64x3(float* address, (Vector64<float> Value1, Vector64<float> Value2, Vector64<float> Value3) value); + +- public unsafe static void StoreVector64x3(ushort* address, (Vector64<ushort> Value1, Vector64<ushort> Value2, Vector64<ushort> Value3) value); + +- public unsafe static void StoreVector64x3(uint* address, (Vector64<uint> Value1, Vector64<uint> Value2, Vector64<uint> Value3) value); + +- public unsafe static void StoreVector64x3AndZip(byte* address, (Vector64<byte> Value1, Vector64<byte> Value2, Vector64<byte> Value3) value); + +- public unsafe static void StoreVector64x3AndZip(short* address, (Vector64<short> Value1, Vector64<short> Value2, Vector64<short> Value3) value); + +- public unsafe static void StoreVector64x3AndZip(int* address, (Vector64<int> Value1, Vector64<int> Value2, Vector64<int> Value3) value); + +- public unsafe static void StoreVector64x3AndZip(sbyte* address, (Vector64<sbyte> Value1, Vector64<sbyte> Value2, Vector64<sbyte> Value3) value); + +- public unsafe static void StoreVector64x3AndZip(float* address, (Vector64<float> Value1, Vector64<float> Value2, Vector64<float> Value3) value); + +- public unsafe static void StoreVector64x3AndZip(ushort* address, (Vector64<ushort> Value1, Vector64<ushort> Value2, Vector64<ushort> Value3) value); + +- public unsafe static void StoreVector64x3AndZip(uint* address, (Vector64<uint> Value1, Vector64<uint> Value2, Vector64<uint> Value3) value); + +- public unsafe static void StoreVector64x4(byte* address, (Vector64<byte> Value1, Vector64<byte> Value2, Vector64<byte> Value3, Vector64<byte> Value4) value); + +- public unsafe static void StoreVector64x4(short* address, (Vector64<short> Value1, Vector64<short> Value2, Vector64<short> Value3, Vector64<short> Value4) value); + +- public unsafe static void StoreVector64x4(int* address, (Vector64<int> Value1, Vector64<int> Value2, Vector64<int> Value3, Vector64<int> Value4) value); + +- public unsafe static void StoreVector64x4(sbyte* address, (Vector64<sbyte> Value1, Vector64<sbyte> Value2, Vector64<sbyte> Value3, Vector64<sbyte> Value4) value); + +- public unsafe static void StoreVector64x4(float* address, (Vector64<float> Value1, Vector64<float> Value2, Vector64<float> Value3, Vector64<float> Value4) value); + +- public unsafe static void StoreVector64x4(ushort* address, (Vector64<ushort> Value1, Vector64<ushort> Value2, Vector64<ushort> Value3, Vector64<ushort> Value4) value); + +- public unsafe static void StoreVector64x4(uint* address, (Vector64<uint> Value1, Vector64<uint> Value2, Vector64<uint> Value3, Vector64<uint> Value4) value); + +- public unsafe static void StoreVector64x4AndZip(byte* address, (Vector64<byte> Value1, Vector64<byte> Value2, Vector64<byte> Value3, Vector64<byte> Value4) value); + +- public unsafe static void StoreVector64x4AndZip(short* address, (Vector64<short> Value1, Vector64<short> Value2, Vector64<short> Value3, Vector64<short> Value4) value); + +- public unsafe static void StoreVector64x4AndZip(int* address, (Vector64<int> Value1, Vector64<int> Value2, Vector64<int> Value3, Vector64<int> Value4) value); + +- public unsafe static void StoreVector64x4AndZip(sbyte* address, (Vector64<sbyte> Value1, Vector64<sbyte> Value2, Vector64<sbyte> Value3, Vector64<sbyte> Value4) value); + +- public unsafe static void StoreVector64x4AndZip(float* address, (Vector64<float> Value1, Vector64<float> Value2, Vector64<float> Value3, Vector64<float> Value4) value); + +- public unsafe static void StoreVector64x4AndZip(ushort* address, (Vector64<ushort> Value1, Vector64<ushort> Value2, Vector64<ushort> Value3, Vector64<ushort> Value4) value); + +- public unsafe static void StoreVector64x4AndZip(uint* address, (Vector64<uint> Value1, Vector64<uint> Value2, Vector64<uint> Value3, Vector64<uint> Value4) value); + ++ public unsafe static void StoreVectorAndZip(byte* address, (Vector64<byte> Value1, Vector64<byte> Value2, Vector64<byte> Value3, Vector64<byte> Value4) value); ++ public unsafe static void StoreVectorAndZip(byte* address, (Vector64<byte> Value1, Vector64<byte> Value2, Vector64<byte> Value3) value); ++ public unsafe static void StoreVectorAndZip(byte* address, (Vector64<byte> Value1, Vector64<byte> Value2) value); ++ public unsafe static void StoreVectorAndZip(short* address, (Vector64<short> Value1, Vector64<short> Value2, Vector64<short> Value3, Vector64<short> Value4) value); ++ public unsafe static void StoreVectorAndZip(short* address, (Vector64<short> Value1, Vector64<short> Value2, Vector64<short> Value3) value); ++ public unsafe static void StoreVectorAndZip(short* address, (Vector64<short> Value1, Vector64<short> Value2) value); ++ public unsafe static void StoreVectorAndZip(int* address, (Vector64<int> Value1, Vector64<int> Value2, Vector64<int> Value3, Vector64<int> Value4) value); ++ public unsafe static void StoreVectorAndZip(int* address, (Vector64<int> Value1, Vector64<int> Value2, Vector64<int> Value3) value); ++ public unsafe static void StoreVectorAndZip(int* address, (Vector64<int> Value1, Vector64<int> Value2) value); ++ public unsafe static void StoreVectorAndZip(sbyte* address, (Vector64<sbyte> Value1, Vector64<sbyte> Value2, Vector64<sbyte> Value3, Vector64<sbyte> Value4) value); ++ public unsafe static void StoreVectorAndZip(sbyte* address, (Vector64<sbyte> Value1, Vector64<sbyte> Value2, Vector64<sbyte> Value3) value); ++ public unsafe static void StoreVectorAndZip(sbyte* address, (Vector64<sbyte> Value1, Vector64<sbyte> Value2) value); ++ public unsafe static void StoreVectorAndZip(float* address, (Vector64<float> Value1, Vector64<float> Value2, Vector64<float> Value3, Vector64<float> Value4) value); ++ public unsafe static void StoreVectorAndZip(float* address, (Vector64<float> Value1, Vector64<float> Value2, Vector64<float> Value3) value); ++ public unsafe static void StoreVectorAndZip(float* address, (Vector64<float> Value1, Vector64<float> Value2) value); ++ public unsafe static void StoreVectorAndZip(ushort* address, (Vector64<ushort> Value1, Vector64<ushort> Value2, Vector64<ushort> Value3, Vector64<ushort> Value4) value); ++ public unsafe static void StoreVectorAndZip(ushort* address, (Vector64<ushort> Value1, Vector64<ushort> Value2, Vector64<ushort> Value3) value); ++ public unsafe static void StoreVectorAndZip(ushort* address, (Vector64<ushort> Value1, Vector64<ushort> Value2) value); ++ public unsafe static void StoreVectorAndZip(uint* address, (Vector64<uint> Value1, Vector64<uint> Value2, Vector64<uint> Value3, Vector64<uint> Value4) value); ++ public unsafe static void StoreVectorAndZip(uint* address, (Vector64<uint> Value1, Vector64<uint> Value2, Vector64<uint> Value3) value); ++ public unsafe static void StoreVectorAndZip(uint* address, (Vector64<uint> Value1, Vector64<uint> Value2) value); + public new abstract class Arm64 : ArmBase.Arm64 { ++ public unsafe static (Vector128<byte> Value1, Vector128<byte> Value2) Load2xVector128(byte* address); ++ public unsafe static (Vector128<double> Value1, Vector128<double> Value2) Load2xVector128(double* address); ++ public unsafe static (Vector128<short> Value1, Vector128<short> Value2) Load2xVector128(short* address); ++ public unsafe static (Vector128<int> Value1, Vector128<int> Value2) Load2xVector128(int* address); ++ public unsafe static (Vector128<long> Value1, Vector128<long> Value2) Load2xVector128(long* address); ++ public unsafe static (Vector128<sbyte> Value1, Vector128<sbyte> Value2) Load2xVector128(sbyte* address); ++ public unsafe static (Vector128<float> Value1, Vector128<float> Value2) Load2xVector128(float* address); ++ public unsafe static (Vector128<ushort> Value1, Vector128<ushort> Value2) Load2xVector128(ushort* address); ++ public unsafe static (Vector128<uint> Value1, Vector128<uint> Value2) Load2xVector128(uint* address); ++ public unsafe static (Vector128<ulong> Value1, Vector128<ulong> Value2) Load2xVector128(ulong* address); ++ public unsafe static (Vector128<byte> Value1, Vector128<byte> Value2) Load2xVector128AndUnzip(byte* address); ++ public unsafe static (Vector128<double> Value1, Vector128<double> Value2) Load2xVector128AndUnzip(double* address); ++ public unsafe static (Vector128<short> Value1, Vector128<short> Value2) Load2xVector128AndUnzip(short* address); ++ public unsafe static (Vector128<int> Value1, Vector128<int> Value2) Load2xVector128AndUnzip(int* address); ++ public unsafe static (Vector128<long> Value1, Vector128<long> Value2) Load2xVector128AndUnzip(long* address); ++ public unsafe static (Vector128<sbyte> Value1, Vector128<sbyte> Value2) Load2xVector128AndUnzip(sbyte* address); ++ public unsafe static (Vector128<float> Value1, Vector128<float> Value2) Load2xVector128AndUnzip(float* address); ++ public unsafe static (Vector128<ushort> Value1, Vector128<ushort> Value2) Load2xVector128AndUnzip(ushort* address); ++ public unsafe static (Vector128<uint> Value1, Vector128<uint> Value2) Load2xVector128AndUnzip(uint* address); ++ public unsafe static (Vector128<ulong> Value1, Vector128<ulong> Value2) Load2xVector128AndUnzip(ulong* address); ++ public unsafe static (Vector128<byte> Value1, Vector128<byte> Value2, Vector128<byte> Value3) Load3xVector128(byte* address); ++ public unsafe static (Vector128<double> Value1, Vector128<double> Value2, Vector128<double> Value3) Load3xVector128(double* address); ++ public unsafe static (Vector128<short> Value1, Vector128<short> Value2, Vector128<short> Value3) Load3xVector128(short* address); ++ public unsafe static (Vector128<int> Value1, Vector128<int> Value2, Vector128<int> Value3) Load3xVector128(int* address); ++ public unsafe static (Vector128<long> Value1, Vector128<long> Value2, Vector128<long> Value3) Load3xVector128(long* address); ++ public unsafe static (Vector128<sbyte> Value1, Vector128<sbyte> Value2, Vector128<sbyte> Value3) Load3xVector128(sbyte* address); ++ public unsafe static (Vector128<float> Value1, Vector128<float> Value2, Vector128<float> Value3) Load3xVector128(float* address); ++ public unsafe static (Vector128<ushort> Value1, Vector128<ushort> Value2, Vector128<ushort> Value3) Load3xVector128(ushort* address); ++ public unsafe static (Vector128<uint> Value1, Vector128<uint> Value2, Vector128<uint> Value3) Load3xVector128(uint* address); ++ public unsafe static (Vector128<ulong> Value1, Vector128<ulong> Value2, Vector128<ulong> Value3) Load3xVector128(ulong* address); ++ public unsafe static (Vector128<byte> Value1, Vector128<byte> Value2, Vector128<byte> Value3) Load3xVector128AndUnzip(byte* address); ++ public unsafe static (Vector128<double> Value1, Vector128<double> Value2, Vector128<double> Value3) Load3xVector128AndUnzip(double* address); ++ public unsafe static (Vector128<short> Value1, Vector128<short> Value2, Vector128<short> Value3) Load3xVector128AndUnzip(short* address); ++ public unsafe static (Vector128<int> Value1, Vector128<int> Value2, Vector128<int> Value3) Load3xVector128AndUnzip(int* address); ++ public unsafe static (Vector128<long> Value1, Vector128<long> Value2, Vector128<long> Value3) Load3xVector128AndUnzip(long* address); ++ public unsafe static (Vector128<sbyte> Value1, Vector128<sbyte> Value2, Vector128<sbyte> Value3) Load3xVector128AndUnzip(sbyte* address); ++ public unsafe static (Vector128<float> Value1, Vector128<float> Value2, Vector128<float> Value3) Load3xVector128AndUnzip(float* address); ++ public unsafe static (Vector128<ushort> Value1, Vector128<ushort> Value2, Vector128<ushort> Value3) Load3xVector128AndUnzip(ushort* address); ++ public unsafe static (Vector128<uint> Value1, Vector128<uint> Value2, Vector128<uint> Value3) Load3xVector128AndUnzip(uint* address); ++ public unsafe static (Vector128<ulong> Value1, Vector128<ulong> Value2, Vector128<ulong> Value3) Load3xVector128AndUnzip(ulong* address); ++ public unsafe static (Vector128<byte> Value1, Vector128<byte> Value2, Vector128<byte> Value3, Vector128<byte> Value4) Load4xVector128(byte* address); ++ public unsafe static (Vector128<double> Value1, Vector128<double> Value2, Vector128<double> Value3, Vector128<double> Value4) Load4xVector128(double* address); ++ public unsafe static (Vector128<short> Value1, Vector128<short> Value2, Vector128<short> Value3, Vector128<short> Value4) Load4xVector128(short* address); ++ public unsafe static (Vector128<int> Value1, Vector128<int> Value2, Vector128<int> Value3, Vector128<int> Value4) Load4xVector128(int* address); ++ public unsafe static (Vector128<long> Value1, Vector128<long> Value2, Vector128<long> Value3, Vector128<long> Value4) Load4xVector128(long* address); ++ public unsafe static (Vector128<sbyte> Value1, Vector128<sbyte> Value2, Vector128<sbyte> Value3, Vector128<sbyte> Value4) Load4xVector128(sbyte* address); ++ public unsafe static (Vector128<float> Value1, Vector128<float> Value2, Vector128<float> Value3, Vector128<float> Value4) Load4xVector128(float* address); ++ public unsafe static (Vector128<ushort> Value1, Vector128<ushort> Value2, Vector128<ushort> Value3, Vector128<ushort> Value4) Load4xVector128(ushort* address); ++ public unsafe static (Vector128<uint> Value1, Vector128<uint> Value2, Vector128<uint> Value3, Vector128<uint> Value4) Load4xVector128(uint* address); ++ public unsafe static (Vector128<ulong> Value1, Vector128<ulong> Value2, Vector128<ulong> Value3, Vector128<ulong> Value4) Load4xVector128(ulong* address); ++ public unsafe static (Vector128<byte> Value1, Vector128<byte> Value2, Vector128<byte> Value3, Vector128<byte> Value4) Load4xVector128AndUnzip(byte* address); ++ public unsafe static (Vector128<double> Value1, Vector128<double> Value2, Vector128<double> Value3, Vector128<double> Value4) Load4xVector128AndUnzip(double* address); ++ public unsafe static (Vector128<short> Value1, Vector128<short> Value2, Vector128<short> Value3, Vector128<short> Value4) Load4xVector128AndUnzip(short* address); ++ public unsafe static (Vector128<int> Value1, Vector128<int> Value2, Vector128<int> Value3, Vector128<int> Value4) Load4xVector128AndUnzip(int* address); ++ public unsafe static (Vector128<long> Value1, Vector128<long> Value2, Vector128<long> Value3, Vector128<long> Value4) Load4xVector128AndUnzip(long* address); ++ public unsafe static (Vector128<sbyte> Value1, Vector128<sbyte> Value2, Vector128<sbyte> Value3, Vector128<sbyte> Value4) Load4xVector128AndUnzip(sbyte* address); ++ public unsafe static (Vector128<float> Value1, Vector128<float> Value2, Vector128<float> Value3, Vector128<float> Value4) Load4xVector128AndUnzip(float* address); ++ public unsafe static (Vector128<ushort> Value1, Vector128<ushort> Value2, Vector128<ushort> Value3, Vector128<ushort> Value4) Load4xVector128AndUnzip(ushort* address); ++ public unsafe static (Vector128<uint> Value1, Vector128<uint> Value2, Vector128<uint> Value3, Vector128<uint> Value4) Load4xVector128AndUnzip(uint* address); ++ public unsafe static (Vector128<ulong> Value1, Vector128<ulong> Value2, Vector128<ulong> Value3, Vector128<ulong> Value4) Load4xVector128AndUnzip(ulong* address); +- public unsafe static (Vector128<byte> Value1, Vector128<byte> Value2) LoadVector128x2(byte* address); + +- public unsafe static (Vector128<double> Value1, Vector128<double> Value2) LoadVector128x2(double* address); + +- public unsafe static (Vector128<short> Value1, Vector128<short> Value2) LoadVector128x2(short* address); + +- public unsafe static (Vector128<int> Value1, Vector128<int> Value2) LoadVector128x2(int* address); + +- public unsafe static (Vector128<long> Value1, Vector128<long> Value2) LoadVector128x2(long* address); + +- public unsafe static (Vector128<sbyte> Value1, Vector128<sbyte> Value2) LoadVector128x2(sbyte* address); + +- public unsafe static (Vector128<float> Value1, Vector128<float> Value2) LoadVector128x2(float* address); + +- public unsafe static (Vector128<ushort> Value1, Vector128<ushort> Value2) LoadVector128x2(ushort* address); + +- public unsafe static (Vector128<uint> Value1, Vector128<uint> Value2) LoadVector128x2(uint* address); + +- public unsafe static (Vector128<ulong> Value1, Vector128<ulong> Value2) LoadVector128x2(ulong* address); + +- public unsafe static (Vector128<byte> Value1, Vector128<byte> Value2) LoadVector128x2AndUnzip(byte* address); + +- public unsafe static (Vector128<double> Value1, Vector128<double> Value2) LoadVector128x2AndUnzip(double* address); + +- public unsafe static (Vector128<short> Value1, Vector128<short> Value2) LoadVector128x2AndUnzip(short* address); + +- public unsafe static (Vector128<int> Value1, Vector128<int> Value2) LoadVector128x2AndUnzip(int* address); + +- public unsafe static (Vector128<long> Value1, Vector128<long> Value2) LoadVector128x2AndUnzip(long* address); + +- public unsafe static (Vector128<sbyte> Value1, Vector128<sbyte> Value2) LoadVector128x2AndUnzip(sbyte* address); + +- public unsafe static (Vector128<float> Value1, Vector128<float> Value2) LoadVector128x2AndUnzip(float* address); + +- public unsafe static (Vector128<ushort> Value1, Vector128<ushort> Value2) LoadVector128x2AndUnzip(ushort* address); + +- public unsafe static (Vector128<uint> Value1, Vector128<uint> Value2) LoadVector128x2AndUnzip(uint* address); + +- public unsafe static (Vector128<ulong> Value1, Vector128<ulong> Value2) LoadVector128x2AndUnzip(ulong* address); + +- public unsafe static (Vector128<byte> Value1, Vector128<byte> Value2, Vector128<byte> Value3) LoadVector128x3(byte* address); + +- public unsafe static (Vector128<double> Value1, Vector128<double> Value2, Vector128<double> Value3) LoadVector128x3(double* address); + +- public unsafe static (Vector128<short> Value1, Vector128<short> Value2, Vector128<short> Value3) LoadVector128x3(short* address); + +- public unsafe static (Vector128<int> Value1, Vector128<int> Value2, Vector128<int> Value3) LoadVector128x3(int* address); + +- public unsafe static (Vector128<long> Value1, Vector128<long> Value2, Vector128<long> Value3) LoadVector128x3(long* address); + +- public unsafe static (Vector128<sbyte> Value1, Vector128<sbyte> Value2, Vector128<sbyte> Value3) LoadVector128x3(sbyte* address); + +- public unsafe static (Vector128<float> Value1, Vector128<float> Value2, Vector128<float> Value3) LoadVector128x3(float* address); + +- public unsafe static (Vector128<ushort> Value1, Vector128<ushort> Value2, Vector128<ushort> Value3) LoadVector128x3(ushort* address); + +- public unsafe static (Vector128<uint> Value1, Vector128<uint> Value2, Vector128<uint> Value3) LoadVector128x3(uint* address); + +- public unsafe static (Vector128<ulong> Value1, Vector128<ulong> Value2, Vector128<ulong> Value3) LoadVector128x3(ulong* address); + +- public unsafe static (Vector128<byte> Value1, Vector128<byte> Value2, Vector128<byte> Value3) LoadVector128x3AndUnzip(byte* address); + +- public unsafe static (Vector128<double> Value1, Vector128<double> Value2, Vector128<double> Value3) LoadVector128x3AndUnzip(double* address); + +- public unsafe static (Vector128<short> Value1, Vector128<short> Value2, Vector128<short> Value3) LoadVector128x3AndUnzip(short* address); + +- public unsafe static (Vector128<int> Value1, Vector128<int> Value2, Vector128<int> Value3) LoadVector128x3AndUnzip(int* address); + +- public unsafe static (Vector128<long> Value1, Vector128<long> Value2, Vector128<long> Value3) LoadVector128x3AndUnzip(long* address); + +- public unsafe static (Vector128<sbyte> Value1, Vector128<sbyte> Value2, Vector128<sbyte> Value3) LoadVector128x3AndUnzip(sbyte* address); + +- public unsafe static (Vector128<float> Value1, Vector128<float> Value2, Vector128<float> Value3) LoadVector128x3AndUnzip(float* address); + +- public unsafe static (Vector128<ushort> Value1, Vector128<ushort> Value2, Vector128<ushort> Value3) LoadVector128x3AndUnzip(ushort* address); + +- public unsafe static (Vector128<uint> Value1, Vector128<uint> Value2, Vector128<uint> Value3) LoadVector128x3AndUnzip(uint* address); + +- public unsafe static (Vector128<ulong> Value1, Vector128<ulong> Value2, Vector128<ulong> Value3) LoadVector128x3AndUnzip(ulong* address); + +- public unsafe static (Vector128<byte> Value1, Vector128<byte> Value2, Vector128<byte> Value3, Vector128<byte> Value4) LoadVector128x4(byte* address); + +- public unsafe static (Vector128<double> Value1, Vector128<double> Value2, Vector128<double> Value3, Vector128<double> Value4) LoadVector128x4(double* address); + +- public unsafe static (Vector128<short> Value1, Vector128<short> Value2, Vector128<short> Value3, Vector128<short> Value4) LoadVector128x4(short* address); + +- public unsafe static (Vector128<int> Value1, Vector128<int> Value2, Vector128<int> Value3, Vector128<int> Value4) LoadVector128x4(int* address); + +- public unsafe static (Vector128<long> Value1, Vector128<long> Value2, Vector128<long> Value3, Vector128<long> Value4) LoadVector128x4(long* address); + +- public unsafe static (Vector128<sbyte> Value1, Vector128<sbyte> Value2, Vector128<sbyte> Value3, Vector128<sbyte> Value4) LoadVector128x4(sbyte* address); + +- public unsafe static (Vector128<float> Value1, Vector128<float> Value2, Vector128<float> Value3, Vector128<float> Value4) LoadVector128x4(float* address); + +- public unsafe static (Vector128<ushort> Value1, Vector128<ushort> Value2, Vector128<ushort> Value3, Vector128<ushort> Value4) LoadVector128x4(ushort* address); + +- public unsafe static (Vector128<uint> Value1, Vector128<uint> Value2, Vector128<uint> Value3, Vector128<uint> Value4) LoadVector128x4(uint* address); + +- public unsafe static (Vector128<ulong> Value1, Vector128<ulong> Value2, Vector128<ulong> Value3, Vector128<ulong> Value4) LoadVector128x4(ulong* address); + +- public unsafe static (Vector128<byte> Value1, Vector128<byte> Value2, Vector128<byte> Value3, Vector128<byte> Value4) LoadVector128x4AndUnzip(byte* address); + +- public unsafe static (Vector128<double> Value1, Vector128<double> Value2, Vector128<double> Value3, Vector128<double> Value4) LoadVector128x4AndUnzip(double* address); + +- public unsafe static (Vector128<short> Value1, Vector128<short> Value2, Vector128<short> Value3, Vector128<short> Value4) LoadVector128x4AndUnzip(short* address); + +- public unsafe static (Vector128<int> Value1, Vector128<int> Value2, Vector128<int> Value3, Vector128<int> Value4) LoadVector128x4AndUnzip(int* address); + +- public unsafe static (Vector128<long> Value1, Vector128<long> Value2, Vector128<long> Value3, Vector128<long> Value4) LoadVector128x4AndUnzip(long* address); + +- public unsafe static (Vector128<sbyte> Value1, Vector128<sbyte> Value2, Vector128<sbyte> Value3, Vector128<sbyte> Value4) LoadVector128x4AndUnzip(sbyte* address); + +- public unsafe static (Vector128<float> Value1, Vector128<float> Value2, Vector128<float> Value3, Vector128<float> Value4) LoadVector128x4AndUnzip(float* address); + +- public unsafe static (Vector128<ushort> Value1, Vector128<ushort> Value2, Vector128<ushort> Value3, Vector128<ushort> Value4) LoadVector128x4AndUnzip(ushort* address); + +- public unsafe static (Vector128<uint> Value1, Vector128<uint> Value2, Vector128<uint> Value3, Vector128<uint> Value4) LoadVector128x4AndUnzip(uint* address); + +- public unsafe static (Vector128<ulong> Value1, Vector128<ulong> Value2, Vector128<ulong> Value3, Vector128<ulong> Value4) LoadVector128x4AndUnzip(ulong* address); + ++ public unsafe static void Store(byte* address, (Vector128<byte> Value1, Vector128<byte> Value2, Vector128<byte> Value3, Vector128<byte> Value4) value); ++ public unsafe static void Store(byte* address, (Vector128<byte> Value1, Vector128<byte> Value2, Vector128<byte> Value3) value); ++ public unsafe static void Store(byte* address, (Vector128<byte> Value1, Vector128<byte> Value2) value); ++ public unsafe static void Store(double* address, (Vector128<double> Value1, Vector128<double> Value2, Vector128<double> Value3, Vector128<double> Value4) value); ++ public unsafe static void Store(double* address, (Vector128<double> Value1, Vector128<double> Value2, Vector128<double> Value3) value); ++ public unsafe static void Store(double* address, (Vector128<double> Value1, Vector128<double> Value2) value); ++ public unsafe static void Store(short* address, (Vector128<short> Value1, Vector128<short> Value2, Vector128<short> Value3, Vector128<short> Value4) value); ++ public unsafe static void Store(short* address, (Vector128<short> Value1, Vector128<short> Value2, Vector128<short> Value3) value); ++ public unsafe static void Store(short* address, (Vector128<short> Value1, Vector128<short> Value2) value); ++ public unsafe static void Store(int* address, (Vector128<int> Value1, Vector128<int> Value2, Vector128<int> Value3, Vector128<int> Value4) value); ++ public unsafe static void Store(int* address, (Vector128<int> Value1, Vector128<int> Value2, Vector128<int> Value3) value); ++ public unsafe static void Store(int* address, (Vector128<int> Value1, Vector128<int> Value2) value); ++ public unsafe static void Store(long* address, (Vector128<long> Value1, Vector128<long> Value2, Vector128<long> Value3, Vector128<long> Value4) value); ++ public unsafe static void Store(long* address, (Vector128<long> Value1, Vector128<long> Value2, Vector128<long> Value3) value); ++ public unsafe static void Store(long* address, (Vector128<long> Value1, Vector128<long> Value2) value); ++ public unsafe static void Store(sbyte* address, (Vector128<sbyte> Value1, Vector128<sbyte> Value2, Vector128<sbyte> Value3, Vector128<sbyte> Value4) value); ++ public unsafe static void Store(sbyte* address, (Vector128<sbyte> Value1, Vector128<sbyte> Value2, Vector128<sbyte> Value3) value); ++ public unsafe static void Store(sbyte* address, (Vector128<sbyte> Value1, Vector128<sbyte> Value2) value); ++ public unsafe static void Store(float* address, (Vector128<float> Value1, Vector128<float> Value2, Vector128<float> Value3, Vector128<float> Value4) value); ++ public unsafe static void Store(float* address, (Vector128<float> Value1, Vector128<float> Value2, Vector128<float> Value3) value); ++ public unsafe static void Store(float* address, (Vector128<float> Value1, Vector128<float> Value2) value); ++ public unsafe static void Store(ushort* address, (Vector128<ushort> Value1, Vector128<ushort> Value2, Vector128<ushort> Value3, Vector128<ushort> Value4) value); ++ public unsafe static void Store(ushort* address, (Vector128<ushort> Value1, Vector128<ushort> Value2, Vector128<ushort> Value3) value); ++ public unsafe static void Store(ushort* address, (Vector128<ushort> Value1, Vector128<ushort> Value2) value); ++ public unsafe static void Store(uint* address, (Vector128<uint> Value1, Vector128<uint> Value2, Vector128<uint> Value3, Vector128<uint> Value4) value); ++ public unsafe static void Store(uint* address, (Vector128<uint> Value1, Vector128<uint> Value2, Vector128<uint> Value3) value); ++ public unsafe static void Store(uint* address, (Vector128<uint> Value1, Vector128<uint> Value2) value); ++ public unsafe static void Store(ulong* address, (Vector128<ulong> Value1, Vector128<ulong> Value2, Vector128<ulong> Value3, Vector128<ulong> Value4) value); ++ public unsafe static void Store(ulong* address, (Vector128<ulong> Value1, Vector128<ulong> Value2, Vector128<ulong> Value3) value); ++ public unsafe static void Store(ulong* address, (Vector128<ulong> Value1, Vector128<ulong> Value2) value); +- public unsafe static void StoreVector128x2(byte* address, (Vector128<byte> Value1, Vector128<byte> Value2) value); + +- public unsafe static void StoreVector128x2(double* address, (Vector128<double> Value1, Vector128<double> Value2) value); + +- public unsafe static void StoreVector128x2(short* address, (Vector128<short> Value1, Vector128<short> Value2) value); + +- public unsafe static void StoreVector128x2(int* address, (Vector128<int> Value1, Vector128<int> Value2) value); + +- public unsafe static void StoreVector128x2(long* address, (Vector128<long> Value1, Vector128<long> Value2) value); + +- public unsafe static void StoreVector128x2(sbyte* address, (Vector128<sbyte> Value1, Vector128<sbyte> Value2) value); + +- public unsafe static void StoreVector128x2(float* address, (Vector128<float> Value1, Vector128<float> Value2) value); + +- public unsafe static void StoreVector128x2(ushort* address, (Vector128<ushort> Value1, Vector128<ushort> Value2) value); + +- public unsafe static void StoreVector128x2(uint* address, (Vector128<uint> Value1, Vector128<uint> Value2) value); + +- public unsafe static void StoreVector128x2(ulong* address, (Vector128<ulong> Value1, Vector128<ulong> Value2) value); + +- public unsafe static void StoreVector128x2AndZip(byte* address, (Vector128<byte> Value1, Vector128<byte> Value2) value); + +- public unsafe static void StoreVector128x2AndZip(double* address, (Vector128<double> Value1, Vector128<double> Value2) value); + +- public unsafe static void StoreVector128x2AndZip(short* address, (Vector128<short> Value1, Vector128<short> Value2) value); + +- public unsafe static void StoreVector128x2AndZip(int* address, (Vector128<int> Value1, Vector128<int> Value2) value); + +- public unsafe static void StoreVector128x2AndZip(long* address, (Vector128<long> Value1, Vector128<long> Value2) value); + +- public unsafe static void StoreVector128x2AndZip(sbyte* address, (Vector128<sbyte> Value1, Vector128<sbyte> Value2) value); + +- public unsafe static void StoreVector128x2AndZip(float* address, (Vector128<float> Value1, Vector128<float> Value2) value); + +- public unsafe static void StoreVector128x2AndZip(ushort* address, (Vector128<ushort> Value1, Vector128<ushort> Value2) value); + +- public unsafe static void StoreVector128x2AndZip(uint* address, (Vector128<uint> Value1, Vector128<uint> Value2) value); + +- public unsafe static void StoreVector128x2AndZip(ulong* address, (Vector128<ulong> Value1, Vector128<ulong> Value2) value); + +- public unsafe static void StoreVector128x3(byte* address, (Vector128<byte> Value1, Vector128<byte> Value2, Vector128<byte> Value3) value); + +- public unsafe static void StoreVector128x3(double* address, (Vector128<double> Value1, Vector128<double> Value2, Vector128<double> Value3) value); + +- public unsafe static void StoreVector128x3(short* address, (Vector128<short> Value1, Vector128<short> Value2, Vector128<short> Value3) value); + +- public unsafe static void StoreVector128x3(int* address, (Vector128<int> Value1, Vector128<int> Value2, Vector128<int> Value3) value); + +- public unsafe static void StoreVector128x3(long* address, (Vector128<long> Value1, Vector128<long> Value2, Vector128<long> Value3) value); + +- public unsafe static void StoreVector128x3(sbyte* address, (Vector128<sbyte> Value1, Vector128<sbyte> Value2, Vector128<sbyte> Value3) value); + +- public unsafe static void StoreVector128x3(float* address, (Vector128<float> Value1, Vector128<float> Value2, Vector128<float> Value3) value); + +- public unsafe static void StoreVector128x3(ushort* address, (Vector128<ushort> Value1, Vector128<ushort> Value2, Vector128<ushort> Value3) value); + +- public unsafe static void StoreVector128x3(uint* address, (Vector128<uint> Value1, Vector128<uint> Value2, Vector128<uint> Value3) value); + +- public unsafe static void StoreVector128x3(ulong* address, (Vector128<ulong> Value1, Vector128<ulong> Value2, Vector128<ulong> Value3) value); + +- public unsafe static void StoreVector128x3AndZip(byte* address, (Vector128<byte> Value1, Vector128<byte> Value2, Vector128<byte> Value3) value); + +- public unsafe static void StoreVector128x3AndZip(double* address, (Vector128<double> Value1, Vector128<double> Value2, Vector128<double> Value3) value); + +- public unsafe static void StoreVector128x3AndZip(short* address, (Vector128<short> Value1, Vector128<short> Value2, Vector128<short> Value3) value); + +- public unsafe static void StoreVector128x3AndZip(int* address, (Vector128<int> Value1, Vector128<int> Value2, Vector128<int> Value3) value); + +- public unsafe static void StoreVector128x3AndZip(long* address, (Vector128<long> Value1, Vector128<long> Value2, Vector128<long> Value3) value); + +- public unsafe static void StoreVector128x3AndZip(sbyte* address, (Vector128<sbyte> Value1, Vector128<sbyte> Value2, Vector128<sbyte> Value3) value); + +- public unsafe static void StoreVector128x3AndZip(float* address, (Vector128<float> Value1, Vector128<float> Value2, Vector128<float> Value3) value); + +- public unsafe static void StoreVector128x3AndZip(ushort* address, (Vector128<ushort> Value1, Vector128<ushort> Value2, Vector128<ushort> Value3) value); + +- public unsafe static void StoreVector128x3AndZip(uint* address, (Vector128<uint> Value1, Vector128<uint> Value2, Vector128<uint> Value3) value); + +- public unsafe static void StoreVector128x3AndZip(ulong* address, (Vector128<ulong> Value1, Vector128<ulong> Value2, Vector128<ulong> Value3) value); + +- public unsafe static void StoreVector128x4(byte* address, (Vector128<byte> Value1, Vector128<byte> Value2, Vector128<byte> Value3, Vector128<byte> Value4) value); + +- public unsafe static void StoreVector128x4(double* address, (Vector128<double> Value1, Vector128<double> Value2, Vector128<double> Value3, Vector128<double> Value4) value); + +- public unsafe static void StoreVector128x4(short* address, (Vector128<short> Value1, Vector128<short> Value2, Vector128<short> Value3, Vector128<short> Value4) value); + +- public unsafe static void StoreVector128x4(int* address, (Vector128<int> Value1, Vector128<int> Value2, Vector128<int> Value3, Vector128<int> Value4) value); + +- public unsafe static void StoreVector128x4(long* address, (Vector128<long> Value1, Vector128<long> Value2, Vector128<long> Value3, Vector128<long> Value4) value); + +- public unsafe static void StoreVector128x4(sbyte* address, (Vector128<sbyte> Value1, Vector128<sbyte> Value2, Vector128<sbyte> Value3, Vector128<sbyte> Value4) value); + +- public unsafe static void StoreVector128x4(float* address, (Vector128<float> Value1, Vector128<float> Value2, Vector128<float> Value3, Vector128<float> Value4) value); + +- public unsafe static void StoreVector128x4(ushort* address, (Vector128<ushort> Value1, Vector128<ushort> Value2, Vector128<ushort> Value3, Vector128<ushort> Value4) value); + +- public unsafe static void StoreVector128x4(uint* address, (Vector128<uint> Value1, Vector128<uint> Value2, Vector128<uint> Value3, Vector128<uint> Value4) value); + +- public unsafe static void StoreVector128x4(ulong* address, (Vector128<ulong> Value1, Vector128<ulong> Value2, Vector128<ulong> Value3, Vector128<ulong> Value4) value); + +- public unsafe static void StoreVector128x4AndZip(byte* address, (Vector128<byte> Value1, Vector128<byte> Value2, Vector128<byte> Value3, Vector128<byte> Value4) value); + +- public unsafe static void StoreVector128x4AndZip(double* address, (Vector128<double> Value1, Vector128<double> Value2, Vector128<double> Value3, Vector128<double> Value4) value); + +- public unsafe static void StoreVector128x4AndZip(short* address, (Vector128<short> Value1, Vector128<short> Value2, Vector128<short> Value3, Vector128<short> Value4) value); + +- public unsafe static void StoreVector128x4AndZip(int* address, (Vector128<int> Value1, Vector128<int> Value2, Vector128<int> Value3, Vector128<int> Value4) value); + +- public unsafe static void StoreVector128x4AndZip(long* address, (Vector128<long> Value1, Vector128<long> Value2, Vector128<long> Value3, Vector128<long> Value4) value); + +- public unsafe static void StoreVector128x4AndZip(sbyte* address, (Vector128<sbyte> Value1, Vector128<sbyte> Value2, Vector128<sbyte> Value3, Vector128<sbyte> Value4) value); + +- public unsafe static void StoreVector128x4AndZip(float* address, (Vector128<float> Value1, Vector128<float> Value2, Vector128<float> Value3, Vector128<float> Value4) value); + +- public unsafe static void StoreVector128x4AndZip(ushort* address, (Vector128<ushort> Value1, Vector128<ushort> Value2, Vector128<ushort> Value3, Vector128<ushort> Value4) value); + +- public unsafe static void StoreVector128x4AndZip(uint* address, (Vector128<uint> Value1, Vector128<uint> Value2, Vector128<uint> Value3, Vector128<uint> Value4) value); + +- public unsafe static void StoreVector128x4AndZip(ulong* address, (Vector128<ulong> Value1, Vector128<ulong> Value2, Vector128<ulong> Value3, Vector128<ulong> Value4) value); + ++ public unsafe static void StoreVectorAndZip(byte* address, (Vector128<byte> Value1, Vector128<byte> Value2, Vector128<byte> Value3, Vector128<byte> Value4) value); ++ public unsafe static void StoreVectorAndZip(byte* address, (Vector128<byte> Value1, Vector128<byte> Value2, Vector128<byte> Value3) value); ++ public unsafe static void StoreVectorAndZip(byte* address, (Vector128<byte> Value1, Vector128<byte> Value2) value); ++ public unsafe static void StoreVectorAndZip(double* address, (Vector128<double> Value1, Vector128<double> Value2, Vector128<double> Value3, Vector128<double> Value4) value); ++ public unsafe static void StoreVectorAndZip(double* address, (Vector128<double> Value1, Vector128<double> Value2, Vector128<double> Value3) value); ++ public unsafe static void StoreVectorAndZip(double* address, (Vector128<double> Value1, Vector128<double> Value2) value); ++ public unsafe static void StoreVectorAndZip(short* address, (Vector128<short> Value1, Vector128<short> Value2, Vector128<short> Value3, Vector128<short> Value4) value); ++ public unsafe static void StoreVectorAndZip(short* address, (Vector128<short> Value1, Vector128<short> Value2, Vector128<short> Value3) value); ++ public unsafe static void StoreVectorAndZip(short* address, (Vector128<short> Value1, Vector128<short> Value2) value); ++ public unsafe static void StoreVectorAndZip(int* address, (Vector128<int> Value1, Vector128<int> Value2, Vector128<int> Value3, Vector128<int> Value4) value); ++ public unsafe static void StoreVectorAndZip(int* address, (Vector128<int> Value1, Vector128<int> Value2, Vector128<int> Value3) value); ++ public unsafe static void StoreVectorAndZip(int* address, (Vector128<int> Value1, Vector128<int> Value2) value); ++ public unsafe static void StoreVectorAndZip(long* address, (Vector128<long> Value1, Vector128<long> Value2, Vector128<long> Value3, Vector128<long> Value4) value); ++ public unsafe static void StoreVectorAndZip(long* address, (Vector128<long> Value1, Vector128<long> Value2, Vector128<long> Value3) value); ++ public unsafe static void StoreVectorAndZip(long* address, (Vector128<long> Value1, Vector128<long> Value2) value); ++ public unsafe static void StoreVectorAndZip(sbyte* address, (Vector128<sbyte> Value1, Vector128<sbyte> Value2, Vector128<sbyte> Value3, Vector128<sbyte> Value4) value); ++ public unsafe static void StoreVectorAndZip(sbyte* address, (Vector128<sbyte> Value1, Vector128<sbyte> Value2, Vector128<sbyte> Value3) value); ++ public unsafe static void StoreVectorAndZip(sbyte* address, (Vector128<sbyte> Value1, Vector128<sbyte> Value2) value); ++ public unsafe static void StoreVectorAndZip(float* address, (Vector128<float> Value1, Vector128<float> Value2, Vector128<float> Value3, Vector128<float> Value4) value); ++ public unsafe static void StoreVectorAndZip(float* address, (Vector128<float> Value1, Vector128<float> Value2, Vector128<float> Value3) value); ++ public unsafe static void StoreVectorAndZip(float* address, (Vector128<float> Value1, Vector128<float> Value2) value); ++ public unsafe static void StoreVectorAndZip(ushort* address, (Vector128<ushort> Value1, Vector128<ushort> Value2, Vector128<ushort> Value3, Vector128<ushort> Value4) value); ++ public unsafe static void StoreVectorAndZip(ushort* address, (Vector128<ushort> Value1, Vector128<ushort> Value2, Vector128<ushort> Value3) value); ++ public unsafe static void StoreVectorAndZip(ushort* address, (Vector128<ushort> Value1, Vector128<ushort> Value2) value); ++ public unsafe static void StoreVectorAndZip(uint* address, (Vector128<uint> Value1, Vector128<uint> Value2, Vector128<uint> Value3, Vector128<uint> Value4) value); ++ public unsafe static void StoreVectorAndZip(uint* address, (Vector128<uint> Value1, Vector128<uint> Value2, Vector128<uint> Value3) value); ++ public unsafe static void StoreVectorAndZip(uint* address, (Vector128<uint> Value1, Vector128<uint> Value2) value); ++ public unsafe static void StoreVectorAndZip(ulong* address, (Vector128<ulong> Value1, Vector128<ulong> Value2, Vector128<ulong> Value3, Vector128<ulong> Value4) value); ++ public unsafe static void StoreVectorAndZip(ulong* address, (Vector128<ulong> Value1, Vector128<ulong> Value2, Vector128<ulong> Value3) value); ++ public unsafe static void StoreVectorAndZip(ulong* address, (Vector128<ulong> Value1, Vector128<ulong> Value2) value); + } + } + public abstract class Sve : AdvSimd { ++ public static Vector<double> Compact(Vector<double> mask, Vector<double> value); ++ public static Vector<int> Compact(Vector<int> mask, Vector<int> value); ++ public static Vector<long> Compact(Vector<long> mask, Vector<long> value); ++ public static Vector<float> Compact(Vector<float> mask, Vector<float> value); ++ public static Vector<uint> Compact(Vector<uint> mask, Vector<uint> value); ++ public static Vector<ulong> Compact(Vector<ulong> mask, Vector<ulong> value); ++ public static Vector<uint> Compute16BitAddresses(Vector<uint> bases, Vector<int> indices); ++ public static Vector<uint> Compute16BitAddresses(Vector<uint> bases, Vector<uint> indices); ++ public static Vector<ulong> Compute16BitAddresses(Vector<ulong> bases, Vector<long> indices); ++ public static Vector<ulong> Compute16BitAddresses(Vector<ulong> bases, Vector<ulong> indices); ++ public static Vector<uint> Compute32BitAddresses(Vector<uint> bases, Vector<int> indices); ++ public static Vector<uint> Compute32BitAddresses(Vector<uint> bases, Vector<uint> indices); ++ public static Vector<ulong> Compute32BitAddresses(Vector<ulong> bases, Vector<long> indices); ++ public static Vector<ulong> Compute32BitAddresses(Vector<ulong> bases, Vector<ulong> indices); ++ public static Vector<uint> Compute64BitAddresses(Vector<uint> bases, Vector<int> indices); ++ public static Vector<uint> Compute64BitAddresses(Vector<uint> bases, Vector<uint> indices); ++ public static Vector<ulong> Compute64BitAddresses(Vector<ulong> bases, Vector<long> indices); ++ public static Vector<ulong> Compute64BitAddresses(Vector<ulong> bases, Vector<ulong> indices); ++ public static Vector<uint> Compute8BitAddresses(Vector<uint> bases, Vector<int> indices); ++ public static Vector<uint> Compute8BitAddresses(Vector<uint> bases, Vector<uint> indices); ++ public static Vector<ulong> Compute8BitAddresses(Vector<ulong> bases, Vector<long> indices); ++ public static Vector<ulong> Compute8BitAddresses(Vector<ulong> bases, Vector<ulong> indices); ++ public static Vector<int> ConvertToInt32(Vector<double> value); ++ public static Vector<int> ConvertToInt32(Vector<float> value); ++ public static Vector<uint> ConvertToUInt32(Vector<double> value); ++ public static Vector<uint> ConvertToUInt32(Vector<float> value); ++ public unsafe static Vector<double> GatherVector(Vector<double> mask, double* address, Vector<long> indices); ++ public unsafe static Vector<double> GatherVector(Vector<double> mask, double* address, Vector<ulong> indices); ++ public static Vector<double> GatherVector(Vector<double> mask, Vector<ulong> addresses); ++ public unsafe static Vector<int> GatherVector(Vector<int> mask, int* address, Vector<int> indices); ++ public unsafe static Vector<int> GatherVector(Vector<int> mask, int* address, Vector<uint> indices); ++ public unsafe static Vector<long> GatherVector(Vector<long> mask, long* address, Vector<long> indices); ++ public unsafe static Vector<long> GatherVector(Vector<long> mask, long* address, Vector<ulong> indices); ++ public static Vector<long> GatherVector(Vector<long> mask, Vector<ulong> addresses); ++ public unsafe static Vector<float> GatherVector(Vector<float> mask, float* address, Vector<int> indices); ++ public unsafe static Vector<float> GatherVector(Vector<float> mask, float* address, Vector<uint> indices); ++ public unsafe static Vector<uint> GatherVector(Vector<uint> mask, uint* address, Vector<int> indices); ++ public unsafe static Vector<uint> GatherVector(Vector<uint> mask, uint* address, Vector<uint> indices); ++ public static Vector<ulong> GatherVector(Vector<ulong> mask, Vector<ulong> addresses); ++ public unsafe static Vector<ulong> GatherVector(Vector<ulong> mask, ulong* address, Vector<long> indices); ++ public unsafe static Vector<ulong> GatherVector(Vector<ulong> mask, ulong* address, Vector<ulong> indices); ++ public unsafe static Vector<int> GatherVectorByteZeroExtend(Vector<int> mask, byte* address, Vector<int> indices); ++ public unsafe static Vector<int> GatherVectorByteZeroExtend(Vector<int> mask, byte* address, Vector<uint> indices); ++ public unsafe static Vector<long> GatherVectorByteZeroExtend(Vector<long> mask, byte* address, Vector<long> indices); ++ public unsafe static Vector<long> GatherVectorByteZeroExtend(Vector<long> mask, byte* address, Vector<ulong> indices); ++ public static Vector<long> GatherVectorByteZeroExtend(Vector<long> mask, Vector<ulong> addresses); ++ public unsafe static Vector<uint> GatherVectorByteZeroExtend(Vector<uint> mask, byte* address, Vector<int> indices); ++ public unsafe static Vector<uint> GatherVectorByteZeroExtend(Vector<uint> mask, byte* address, Vector<uint> indices); ++ public unsafe static Vector<ulong> GatherVectorByteZeroExtend(Vector<ulong> mask, byte* address, Vector<long> indices); ++ public unsafe static Vector<ulong> GatherVectorByteZeroExtend(Vector<ulong> mask, byte* address, Vector<ulong> indices); ++ public static Vector<ulong> GatherVectorByteZeroExtend(Vector<ulong> mask, Vector<ulong> addresses); ++ public unsafe static Vector<int> GatherVectorInt16SignExtend(Vector<int> mask, short* address, Vector<int> indices); ++ public unsafe static Vector<int> GatherVectorInt16SignExtend(Vector<int> mask, short* address, Vector<uint> indices); ++ public unsafe static Vector<long> GatherVectorInt16SignExtend(Vector<long> mask, short* address, Vector<long> indices); ++ public unsafe static Vector<long> GatherVectorInt16SignExtend(Vector<long> mask, short* address, Vector<ulong> indices); ++ public static Vector<long> GatherVectorInt16SignExtend(Vector<long> mask, Vector<ulong> addresses); ++ public unsafe static Vector<uint> GatherVectorInt16SignExtend(Vector<uint> mask, short* address, Vector<int> indices); ++ public unsafe static Vector<uint> GatherVectorInt16SignExtend(Vector<uint> mask, short* address, Vector<uint> indices); ++ public unsafe static Vector<ulong> GatherVectorInt16SignExtend(Vector<ulong> mask, short* address, Vector<long> indices); ++ public unsafe static Vector<ulong> GatherVectorInt16SignExtend(Vector<ulong> mask, short* address, Vector<ulong> indices); ++ public static Vector<ulong> GatherVectorInt16SignExtend(Vector<ulong> mask, Vector<ulong> addresses); ++ public unsafe static Vector<int> GatherVectorInt16WithByteOffsetsSignExtend(Vector<int> mask, short* address, Vector<int> offsets); ++ public unsafe static Vector<int> GatherVectorInt16WithByteOffsetsSignExtend(Vector<int> mask, short* address, Vector<uint> offsets); ++ public unsafe static Vector<long> GatherVectorInt16WithByteOffsetsSignExtend(Vector<long> mask, short* address, Vector<long> offsets); ++ public unsafe static Vector<long> GatherVectorInt16WithByteOffsetsSignExtend(Vector<long> mask, short* address, Vector<ulong> offsets); ++ public unsafe static Vector<uint> GatherVectorInt16WithByteOffsetsSignExtend(Vector<uint> mask, short* address, Vector<int> offsets); ++ public unsafe static Vector<uint> GatherVectorInt16WithByteOffsetsSignExtend(Vector<uint> mask, short* address, Vector<uint> offsets); ++ public unsafe static Vector<ulong> GatherVectorInt16WithByteOffsetsSignExtend(Vector<ulong> mask, short* address, Vector<long> offsets); ++ public unsafe static Vector<ulong> GatherVectorInt16WithByteOffsetsSignExtend(Vector<ulong> mask, short* address, Vector<ulong> offsets); ++ public unsafe static Vector<long> GatherVectorInt32SignExtend(Vector<long> mask, int* address, Vector<long> indices); ++ public unsafe static Vector<long> GatherVectorInt32SignExtend(Vector<long> mask, int* address, Vector<ulong> indices); ++ public static Vector<long> GatherVectorInt32SignExtend(Vector<long> mask, Vector<ulong> addresses); ++ public unsafe static Vector<ulong> GatherVectorInt32SignExtend(Vector<ulong> mask, int* address, Vector<long> indices); ++ public unsafe static Vector<ulong> GatherVectorInt32SignExtend(Vector<ulong> mask, int* address, Vector<ulong> indices); ++ public static Vector<ulong> GatherVectorInt32SignExtend(Vector<ulong> mask, Vector<ulong> addresses); ++ public unsafe static Vector<long> GatherVectorInt32WithByteOffsetsSignExtend(Vector<long> mask, int* address, Vector<long> offsets); ++ public unsafe static Vector<long> GatherVectorInt32WithByteOffsetsSignExtend(Vector<long> mask, int* address, Vector<ulong> offsets); ++ public unsafe static Vector<ulong> GatherVectorInt32WithByteOffsetsSignExtend(Vector<ulong> mask, int* address, Vector<long> offsets); ++ public unsafe static Vector<ulong> GatherVectorInt32WithByteOffsetsSignExtend(Vector<ulong> mask, int* address, Vector<ulong> offsets); ++ public unsafe static Vector<int> GatherVectorSByteSignExtend(Vector<int> mask, sbyte* address, Vector<int> indices); ++ public unsafe static Vector<int> GatherVectorSByteSignExtend(Vector<int> mask, sbyte* address, Vector<uint> indices); ++ public static Vector<long> GatherVectorSByteSignExtend(Vector<long> mask, Vector<ulong> addresses); ++ public unsafe static Vector<long> GatherVectorSByteSignExtend(Vector<long> mask, sbyte* address, Vector<long> indices); ++ public unsafe static Vector<long> GatherVectorSByteSignExtend(Vector<long> mask, sbyte* address, Vector<ulong> indices); ++ public unsafe static Vector<uint> GatherVectorSByteSignExtend(Vector<uint> mask, sbyte* address, Vector<int> indices); ++ public unsafe static Vector<uint> GatherVectorSByteSignExtend(Vector<uint> mask, sbyte* address, Vector<uint> indices); ++ public static Vector<ulong> GatherVectorSByteSignExtend(Vector<ulong> mask, Vector<ulong> addresses); ++ public unsafe static Vector<ulong> GatherVectorSByteSignExtend(Vector<ulong> mask, sbyte* address, Vector<long> indices); ++ public unsafe static Vector<ulong> GatherVectorSByteSignExtend(Vector<ulong> mask, sbyte* address, Vector<ulong> indices); ++ public unsafe static Vector<int> GatherVectorUInt16WithByteOffsetsZeroExtend(Vector<int> mask, ushort* address, Vector<int> offsets); ++ public unsafe static Vector<int> GatherVectorUInt16WithByteOffsetsZeroExtend(Vector<int> mask, ushort* address, Vector<uint> offsets); ++ public unsafe static Vector<long> GatherVectorUInt16WithByteOffsetsZeroExtend(Vector<long> mask, ushort* address, Vector<long> offsets); ++ public unsafe static Vector<long> GatherVectorUInt16WithByteOffsetsZeroExtend(Vector<long> mask, ushort* address, Vector<ulong> offsets); ++ public unsafe static Vector<uint> GatherVectorUInt16WithByteOffsetsZeroExtend(Vector<uint> mask, ushort* address, Vector<int> offsets); ++ public unsafe static Vector<uint> GatherVectorUInt16WithByteOffsetsZeroExtend(Vector<uint> mask, ushort* address, Vector<uint> offsets); ++ public unsafe static Vector<ulong> GatherVectorUInt16WithByteOffsetsZeroExtend(Vector<ulong> mask, ushort* address, Vector<long> offsets); ++ public unsafe static Vector<ulong> GatherVectorUInt16WithByteOffsetsZeroExtend(Vector<ulong> mask, ushort* address, Vector<ulong> offsets); ++ public unsafe static Vector<int> GatherVectorUInt16ZeroExtend(Vector<int> mask, ushort* address, Vector<int> indices); ++ public unsafe static Vector<int> GatherVectorUInt16ZeroExtend(Vector<int> mask, ushort* address, Vector<uint> indices); ++ public static Vector<long> GatherVectorUInt16ZeroExtend(Vector<long> mask, Vector<ulong> addresses); ++ public unsafe static Vector<long> GatherVectorUInt16ZeroExtend(Vector<long> mask, ushort* address, Vector<long> indices); ++ public unsafe static Vector<long> GatherVectorUInt16ZeroExtend(Vector<long> mask, ushort* address, Vector<ulong> indices); ++ public unsafe static Vector<uint> GatherVectorUInt16ZeroExtend(Vector<uint> mask, ushort* address, Vector<int> indices); ++ public unsafe static Vector<uint> GatherVectorUInt16ZeroExtend(Vector<uint> mask, ushort* address, Vector<uint> indices); ++ public static Vector<ulong> GatherVectorUInt16ZeroExtend(Vector<ulong> mask, Vector<ulong> addresses); ++ public unsafe static Vector<ulong> GatherVectorUInt16ZeroExtend(Vector<ulong> mask, ushort* address, Vector<long> indices); ++ public unsafe static Vector<ulong> GatherVectorUInt16ZeroExtend(Vector<ulong> mask, ushort* address, Vector<ulong> indices); ++ public unsafe static Vector<int> GatherVectorUInt32WithByteOffsetsZeroExtend(Vector<int> mask, uint* address, Vector<int> offsets); ++ public unsafe static Vector<int> GatherVectorUInt32WithByteOffsetsZeroExtend(Vector<int> mask, uint* address, Vector<uint> offsets); ++ public unsafe static Vector<long> GatherVectorUInt32WithByteOffsetsZeroExtend(Vector<long> mask, uint* address, Vector<long> offsets); ++ public unsafe static Vector<long> GatherVectorUInt32WithByteOffsetsZeroExtend(Vector<long> mask, uint* address, Vector<ulong> offsets); ++ public unsafe static Vector<uint> GatherVectorUInt32WithByteOffsetsZeroExtend(Vector<uint> mask, uint* address, Vector<int> offsets); ++ public unsafe static Vector<uint> GatherVectorUInt32WithByteOffsetsZeroExtend(Vector<uint> mask, uint* address, Vector<uint> offsets); ++ public unsafe static Vector<ulong> GatherVectorUInt32WithByteOffsetsZeroExtend(Vector<ulong> mask, uint* address, Vector<long> offsets); ++ public unsafe static Vector<ulong> GatherVectorUInt32WithByteOffsetsZeroExtend(Vector<ulong> mask, uint* address, Vector<ulong> offsets); ++ public unsafe static Vector<int> GatherVectorUInt32ZeroExtend(Vector<int> mask, uint* address, Vector<int> indices); ++ public unsafe static Vector<int> GatherVectorUInt32ZeroExtend(Vector<int> mask, uint* address, Vector<uint> indices); ++ public static Vector<long> GatherVectorUInt32ZeroExtend(Vector<long> mask, Vector<ulong> addresses); ++ public unsafe static Vector<long> GatherVectorUInt32ZeroExtend(Vector<long> mask, uint* address, Vector<long> indices); ++ public unsafe static Vector<long> GatherVectorUInt32ZeroExtend(Vector<long> mask, uint* address, Vector<ulong> indices); ++ public unsafe static Vector<uint> GatherVectorUInt32ZeroExtend(Vector<uint> mask, uint* address, Vector<int> indices); ++ public unsafe static Vector<uint> GatherVectorUInt32ZeroExtend(Vector<uint> mask, uint* address, Vector<uint> indices); ++ public static Vector<ulong> GatherVectorUInt32ZeroExtend(Vector<ulong> mask, Vector<ulong> addresses); ++ public unsafe static Vector<ulong> GatherVectorUInt32ZeroExtend(Vector<ulong> mask, uint* address, Vector<long> indices); ++ public unsafe static Vector<ulong> GatherVectorUInt32ZeroExtend(Vector<ulong> mask, uint* address, Vector<ulong> indices); ++ public unsafe static Vector<double> GatherVectorWithByteOffsets(Vector<double> mask, double* address, Vector<long> offsets); ++ public unsafe static Vector<double> GatherVectorWithByteOffsets(Vector<double> mask, double* address, Vector<ulong> offsets); ++ public unsafe static Vector<int> GatherVectorWithByteOffsets(Vector<int> mask, int* address, Vector<int> offsets); ++ public unsafe static Vector<int> GatherVectorWithByteOffsets(Vector<int> mask, int* address, Vector<uint> offsets); ++ public unsafe static Vector<long> GatherVectorWithByteOffsets(Vector<long> mask, long* address, Vector<long> offsets); ++ public unsafe static Vector<long> GatherVectorWithByteOffsets(Vector<long> mask, long* address, Vector<ulong> offsets); ++ public unsafe static Vector<float> GatherVectorWithByteOffsets(Vector<float> mask, float* address, Vector<int> offsets); ++ public unsafe static Vector<float> GatherVectorWithByteOffsets(Vector<float> mask, float* address, Vector<uint> offsets); ++ public unsafe static Vector<uint> GatherVectorWithByteOffsets(Vector<uint> mask, uint* address, Vector<int> offsets); ++ public unsafe static Vector<uint> GatherVectorWithByteOffsets(Vector<uint> mask, uint* address, Vector<uint> offsets); ++ public unsafe static Vector<ulong> GatherVectorWithByteOffsets(Vector<ulong> mask, ulong* address, Vector<long> offsets); ++ public unsafe static Vector<ulong> GatherVectorWithByteOffsets(Vector<ulong> mask, ulong* address, Vector<ulong> offsets); ++ public static ulong GetActiveElementCount(Vector<byte> mask, Vector<byte> from); ++ public static ulong GetActiveElementCount(Vector<double> mask, Vector<double> from); ++ public static ulong GetActiveElementCount(Vector<short> mask, Vector<short> from); ++ public static ulong GetActiveElementCount(Vector<int> mask, Vector<int> from); ++ public static ulong GetActiveElementCount(Vector<long> mask, Vector<long> from); ++ public static ulong GetActiveElementCount(Vector<sbyte> mask, Vector<sbyte> from); ++ public static ulong GetActiveElementCount(Vector<float> mask, Vector<float> from); ++ public static ulong GetActiveElementCount(Vector<ushort> mask, Vector<ushort> from); ++ public static ulong GetActiveElementCount(Vector<uint> mask, Vector<uint> from); ++ public static ulong GetActiveElementCount(Vector<ulong> mask, Vector<ulong> from); ++ public static Vector<ushort> LeadingSignCount(Vector<short> value); ++ public static Vector<uint> LeadingSignCount(Vector<int> value); ++ public static Vector<ulong> LeadingSignCount(Vector<long> value); ++ public static Vector<byte> LeadingSignCount(Vector<sbyte> value); ++ public static Vector<byte> LeadingZeroCount(Vector<byte> value); ++ public static Vector<ushort> LeadingZeroCount(Vector<short> value); ++ public static Vector<uint> LeadingZeroCount(Vector<int> value); ++ public static Vector<ulong> LeadingZeroCount(Vector<long> value); ++ public static Vector<byte> LeadingZeroCount(Vector<sbyte> value); ++ public static Vector<ushort> LeadingZeroCount(Vector<ushort> value); ++ public static Vector<uint> LeadingZeroCount(Vector<uint> value); ++ public static Vector<ulong> LeadingZeroCount(Vector<ulong> value); ++ public unsafe static (Vector<byte>, Vector<byte>) Load2xVectorAndUnzip(Vector<byte> mask, byte* address); ++ public unsafe static (Vector<double>, Vector<double>) Load2xVectorAndUnzip(Vector<double> mask, double* address); ++ public unsafe static (Vector<short>, Vector<short>) Load2xVectorAndUnzip(Vector<short> mask, short* address); ++ public unsafe static (Vector<int>, Vector<int>) Load2xVectorAndUnzip(Vector<int> mask, int* address); ++ public unsafe static (Vector<long>, Vector<long>) Load2xVectorAndUnzip(Vector<long> mask, long* address); ++ public unsafe static (Vector<sbyte>, Vector<sbyte>) Load2xVectorAndUnzip(Vector<sbyte> mask, sbyte* address); ++ public unsafe static (Vector<float>, Vector<float>) Load2xVectorAndUnzip(Vector<float> mask, float* address); ++ public unsafe static (Vector<ushort>, Vector<ushort>) Load2xVectorAndUnzip(Vector<ushort> mask, ushort* address); ++ public unsafe static (Vector<uint>, Vector<uint>) Load2xVectorAndUnzip(Vector<uint> mask, uint* address); ++ public unsafe static (Vector<ulong>, Vector<ulong>) Load2xVectorAndUnzip(Vector<ulong> mask, ulong* address); ++ public unsafe static (Vector<byte>, Vector<byte>, Vector<byte>) Load3xVectorAndUnzip(Vector<byte> mask, byte* address); ++ public unsafe static (Vector<double>, Vector<double>, Vector<double>) Load3xVectorAndUnzip(Vector<double> mask, double* address); ++ public unsafe static (Vector<short>, Vector<short>, Vector<short>) Load3xVectorAndUnzip(Vector<short> mask, short* address); ++ public unsafe static (Vector<int>, Vector<int>, Vector<int>) Load3xVectorAndUnzip(Vector<int> mask, int* address); ++ public unsafe static (Vector<long>, Vector<long>, Vector<long>) Load3xVectorAndUnzip(Vector<long> mask, long* address); ++ public unsafe static (Vector<sbyte>, Vector<sbyte>, Vector<sbyte>) Load3xVectorAndUnzip(Vector<sbyte> mask, sbyte* address); ++ public unsafe static (Vector<float>, Vector<float>, Vector<float>) Load3xVectorAndUnzip(Vector<float> mask, float* address); ++ public unsafe static (Vector<ushort>, Vector<ushort>, Vector<ushort>) Load3xVectorAndUnzip(Vector<ushort> mask, ushort* address); ++ public unsafe static (Vector<uint>, Vector<uint>, Vector<uint>) Load3xVectorAndUnzip(Vector<uint> mask, uint* address); ++ public unsafe static (Vector<ulong>, Vector<ulong>, Vector<ulong>) Load3xVectorAndUnzip(Vector<ulong> mask, ulong* address); ++ public unsafe static (Vector<byte>, Vector<byte>, Vector<byte>, Vector<byte>) Load4xVectorAndUnzip(Vector<byte> mask, byte* address); ++ public unsafe static (Vector<double>, Vector<double>, Vector<double>, Vector<double>) Load4xVectorAndUnzip(Vector<double> mask, double* address); ++ public unsafe static (Vector<short>, Vector<short>, Vector<short>, Vector<short>) Load4xVectorAndUnzip(Vector<short> mask, short* address); ++ public unsafe static (Vector<int>, Vector<int>, Vector<int>, Vector<int>) Load4xVectorAndUnzip(Vector<int> mask, int* address); ++ public unsafe static (Vector<long>, Vector<long>, Vector<long>, Vector<long>) Load4xVectorAndUnzip(Vector<long> mask, long* address); ++ public unsafe static (Vector<sbyte>, Vector<sbyte>, Vector<sbyte>, Vector<sbyte>) Load4xVectorAndUnzip(Vector<sbyte> mask, sbyte* address); ++ public unsafe static (Vector<float>, Vector<float>, Vector<float>, Vector<float>) Load4xVectorAndUnzip(Vector<float> mask, float* address); ++ public unsafe static (Vector<ushort>, Vector<ushort>, Vector<ushort>, Vector<ushort>) Load4xVectorAndUnzip(Vector<ushort> mask, ushort* address); ++ public unsafe static (Vector<uint>, Vector<uint>, Vector<uint>, Vector<uint>) Load4xVectorAndUnzip(Vector<uint> mask, uint* address); ++ public unsafe static (Vector<ulong>, Vector<ulong>, Vector<ulong>, Vector<ulong>) Load4xVectorAndUnzip(Vector<ulong> mask, ulong* address); ++ public unsafe static Vector<byte> LoadVector128AndReplicateToVector(Vector<byte> mask, byte* address); ++ public unsafe static Vector<double> LoadVector128AndReplicateToVector(Vector<double> mask, double* address); ++ public unsafe static Vector<short> LoadVector128AndReplicateToVector(Vector<short> mask, short* address); ++ public unsafe static Vector<int> LoadVector128AndReplicateToVector(Vector<int> mask, int* address); ++ public unsafe static Vector<long> LoadVector128AndReplicateToVector(Vector<long> mask, long* address); ++ public unsafe static Vector<sbyte> LoadVector128AndReplicateToVector(Vector<sbyte> mask, sbyte* address); ++ public unsafe static Vector<float> LoadVector128AndReplicateToVector(Vector<float> mask, float* address); ++ public unsafe static Vector<ushort> LoadVector128AndReplicateToVector(Vector<ushort> mask, ushort* address); ++ public unsafe static Vector<uint> LoadVector128AndReplicateToVector(Vector<uint> mask, uint* address); ++ public unsafe static Vector<ulong> LoadVector128AndReplicateToVector(Vector<ulong> mask, ulong* address); ++ public unsafe static Vector<short> LoadVectorByteNonFaultingZeroExtendToInt16(byte* address); ++ public unsafe static Vector<int> LoadVectorByteNonFaultingZeroExtendToInt32(byte* address); ++ public unsafe static Vector<long> LoadVectorByteNonFaultingZeroExtendToInt64(byte* address); ++ public unsafe static Vector<ushort> LoadVectorByteNonFaultingZeroExtendToUInt16(byte* address); ++ public unsafe static Vector<uint> LoadVectorByteNonFaultingZeroExtendToUInt32(byte* address); ++ public unsafe static Vector<ulong> LoadVectorByteNonFaultingZeroExtendToUInt64(byte* address); ++ public unsafe static Vector<int> LoadVectorInt16NonFaultingSignExtendToInt32(short* address); ++ public unsafe static Vector<long> LoadVectorInt16NonFaultingSignExtendToInt64(short* address); ++ public unsafe static Vector<uint> LoadVectorInt16NonFaultingSignExtendToUInt32(short* address); ++ public unsafe static Vector<ulong> LoadVectorInt16NonFaultingSignExtendToUInt64(short* address); ++ public unsafe static Vector<long> LoadVectorInt32NonFaultingSignExtendToInt64(int* address); ++ public unsafe static Vector<ulong> LoadVectorInt32NonFaultingSignExtendToUInt64(int* address); ++ public unsafe static Vector<byte> LoadVectorNonFaulting(byte* address); ++ public unsafe static Vector<double> LoadVectorNonFaulting(double* address); ++ public unsafe static Vector<short> LoadVectorNonFaulting(short* address); ++ public unsafe static Vector<int> LoadVectorNonFaulting(int* address); ++ public unsafe static Vector<long> LoadVectorNonFaulting(long* address); ++ public unsafe static Vector<sbyte> LoadVectorNonFaulting(sbyte* address); ++ public unsafe static Vector<float> LoadVectorNonFaulting(float* address); ++ public unsafe static Vector<ushort> LoadVectorNonFaulting(ushort* address); ++ public unsafe static Vector<uint> LoadVectorNonFaulting(uint* address); ++ public unsafe static Vector<ulong> LoadVectorNonFaulting(ulong* address); ++ public unsafe static Vector<byte> LoadVectorNonTemporal(Vector<byte> mask, byte* address); ++ public unsafe static Vector<double> LoadVectorNonTemporal(Vector<double> mask, double* address); ++ public unsafe static Vector<short> LoadVectorNonTemporal(Vector<short> mask, short* address); ++ public unsafe static Vector<int> LoadVectorNonTemporal(Vector<int> mask, int* address); ++ public unsafe static Vector<long> LoadVectorNonTemporal(Vector<long> mask, long* address); ++ public unsafe static Vector<sbyte> LoadVectorNonTemporal(Vector<sbyte> mask, sbyte* address); ++ public unsafe static Vector<float> LoadVectorNonTemporal(Vector<float> mask, float* address); ++ public unsafe static Vector<ushort> LoadVectorNonTemporal(Vector<ushort> mask, ushort* address); ++ public unsafe static Vector<uint> LoadVectorNonTemporal(Vector<uint> mask, uint* address); ++ public unsafe static Vector<ulong> LoadVectorNonTemporal(Vector<ulong> mask, ulong* address); ++ public unsafe static Vector<short> LoadVectorSByteNonFaultingSignExtendToInt16(sbyte* address); ++ public unsafe static Vector<int> LoadVectorSByteNonFaultingSignExtendToInt32(sbyte* address); ++ public unsafe static Vector<long> LoadVectorSByteNonFaultingSignExtendToInt64(sbyte* address); ++ public unsafe static Vector<ushort> LoadVectorSByteNonFaultingSignExtendToUInt16(sbyte* address); ++ public unsafe static Vector<uint> LoadVectorSByteNonFaultingSignExtendToUInt32(sbyte* address); ++ public unsafe static Vector<ulong> LoadVectorSByteNonFaultingSignExtendToUInt64(sbyte* address); ++ public unsafe static Vector<int> LoadVectorUInt16NonFaultingZeroExtendToInt32(ushort* address); ++ public unsafe static Vector<long> LoadVectorUInt16NonFaultingZeroExtendToInt64(ushort* address); ++ public unsafe static Vector<uint> LoadVectorUInt16NonFaultingZeroExtendToUInt32(ushort* address); ++ public unsafe static Vector<ulong> LoadVectorUInt16NonFaultingZeroExtendToUInt64(ushort* address); ++ public unsafe static Vector<long> LoadVectorUInt32NonFaultingZeroExtendToInt64(uint* address); ++ public unsafe static Vector<ulong> LoadVectorUInt32NonFaultingZeroExtendToUInt64(uint* address); ++ public static Vector<byte> PopCount(Vector<byte> value); ++ public static Vector<ulong> PopCount(Vector<double> value); ++ public static Vector<ushort> PopCount(Vector<short> value); ++ public static Vector<uint> PopCount(Vector<int> value); ++ public static Vector<ulong> PopCount(Vector<long> value); ++ public static Vector<byte> PopCount(Vector<sbyte> value); ++ public static Vector<uint> PopCount(Vector<float> value); ++ public static Vector<ushort> PopCount(Vector<ushort> value); ++ public static Vector<uint> PopCount(Vector<uint> value); ++ public static Vector<ulong> PopCount(Vector<ulong> value); ++ public unsafe static void PrefetchBytes(Vector<byte> mask, void* address, SvePrefetchType prefetchType); ++ public unsafe static void PrefetchInt16(Vector<ushort> mask, void* address, SvePrefetchType prefetchType); ++ public unsafe static void PrefetchInt32(Vector<uint> mask, void* address, SvePrefetchType prefetchType); ++ public unsafe static void PrefetchInt64(Vector<ulong> mask, void* address, SvePrefetchType prefetchType); ++ public static Vector<byte> ReverseElement(Vector<byte> value); ++ public static Vector<double> ReverseElement(Vector<double> value); ++ public static Vector<short> ReverseElement(Vector<short> value); ++ public static Vector<int> ReverseElement(Vector<int> value); ++ public static Vector<long> ReverseElement(Vector<long> value); ++ public static Vector<sbyte> ReverseElement(Vector<sbyte> value); ++ public static Vector<float> ReverseElement(Vector<float> value); ++ public static Vector<ushort> ReverseElement(Vector<ushort> value); ++ public static Vector<uint> ReverseElement(Vector<uint> value); ++ public static Vector<ulong> ReverseElement(Vector<ulong> value); ++ public static Vector<int> ReverseElement16(Vector<int> value); ++ public static Vector<long> ReverseElement16(Vector<long> value); ++ public static Vector<uint> ReverseElement16(Vector<uint> value); ++ public static Vector<ulong> ReverseElement16(Vector<ulong> value); ++ public static Vector<long> ReverseElement32(Vector<long> value); ++ public static Vector<ulong> ReverseElement32(Vector<ulong> value); ++ public static Vector<short> ReverseElement8(Vector<short> value); ++ public static Vector<int> ReverseElement8(Vector<int> value); ++ public static Vector<long> ReverseElement8(Vector<long> value); ++ public static Vector<ushort> ReverseElement8(Vector<ushort> value); ++ public static Vector<uint> ReverseElement8(Vector<uint> value); ++ public static Vector<ulong> ReverseElement8(Vector<ulong> value); ++ public static Vector<double> RoundAwayFromZero(Vector<double> value); ++ public static Vector<float> RoundAwayFromZero(Vector<float> value); ++ public static Vector<double> RoundToNearest(Vector<double> value); ++ public static Vector<float> RoundToNearest(Vector<float> value); ++ public static Vector<double> RoundToNegativeInfinity(Vector<double> value); ++ public static Vector<float> RoundToNegativeInfinity(Vector<float> value); ++ public static Vector<double> RoundToPositiveInfinity(Vector<double> value); ++ public static Vector<float> RoundToPositiveInfinity(Vector<float> value); ++ public static Vector<double> RoundToZero(Vector<double> value); ++ public static Vector<float> RoundToZero(Vector<float> value); ++ public static int SaturatingDecrementBy16BitElementCount(int value, byte scale, SveMaskPattern pattern = SveMaskPattern.All); ++ public static long SaturatingDecrementBy16BitElementCount(long value, byte scale, SveMaskPattern pattern = SveMaskPattern.All); ++ public static Vector<short> SaturatingDecrementBy16BitElementCount(Vector<short> value, byte scale, SveMaskPattern pattern = SveMaskPattern.All); ++ public static Vector<ushort> SaturatingDecrementBy16BitElementCount(Vector<ushort> value, byte scale, SveMaskPattern pattern = SveMaskPattern.All); ++ public static uint SaturatingDecrementBy16BitElementCount(uint value, byte scale, SveMaskPattern pattern = SveMaskPattern.All); ++ public static ulong SaturatingDecrementBy16BitElementCount(ulong value, byte scale, SveMaskPattern pattern = SveMaskPattern.All); ++ public static int SaturatingDecrementBy32BitElementCount(int value, byte scale, SveMaskPattern pattern = SveMaskPattern.All); ++ public static long SaturatingDecrementBy32BitElementCount(long value, byte scale, SveMaskPattern pattern = SveMaskPattern.All); ++ public static Vector<int> SaturatingDecrementBy32BitElementCount(Vector<int> value, byte scale, SveMaskPattern pattern = SveMaskPattern.All); ++ public static Vector<uint> SaturatingDecrementBy32BitElementCount(Vector<uint> value, byte scale, SveMaskPattern pattern = SveMaskPattern.All); ++ public static uint SaturatingDecrementBy32BitElementCount(uint value, byte scale, SveMaskPattern pattern = SveMaskPattern.All); ++ public static ulong SaturatingDecrementBy32BitElementCount(ulong value, byte scale, SveMaskPattern pattern = SveMaskPattern.All); ++ public static int SaturatingDecrementBy64BitElementCount(int value, byte scale, SveMaskPattern pattern = SveMaskPattern.All); ++ public static long SaturatingDecrementBy64BitElementCount(long value, byte scale, SveMaskPattern pattern = SveMaskPattern.All); ++ public static Vector<long> SaturatingDecrementBy64BitElementCount(Vector<long> value, byte scale, SveMaskPattern pattern = SveMaskPattern.All); ++ public static Vector<ulong> SaturatingDecrementBy64BitElementCount(Vector<ulong> value, byte scale, SveMaskPattern pattern = SveMaskPattern.All); ++ public static uint SaturatingDecrementBy64BitElementCount(uint value, byte scale, SveMaskPattern pattern = SveMaskPattern.All); ++ public static ulong SaturatingDecrementBy64BitElementCount(ulong value, byte scale, SveMaskPattern pattern = SveMaskPattern.All); ++ public static int SaturatingDecrementBy8BitElementCount(int value, byte scale, SveMaskPattern pattern = SveMaskPattern.All); ++ public static long SaturatingDecrementBy8BitElementCount(long value, byte scale, SveMaskPattern pattern = SveMaskPattern.All); ++ public static uint SaturatingDecrementBy8BitElementCount(uint value, byte scale, SveMaskPattern pattern = SveMaskPattern.All); ++ public static ulong SaturatingDecrementBy8BitElementCount(ulong value, byte scale, SveMaskPattern pattern = SveMaskPattern.All); ++ public static long SaturatingDecrementByActiveElementCount(int value, Vector<byte> from); ++ public static long SaturatingDecrementByActiveElementCount(int value, Vector<ushort> from); ++ public static long SaturatingDecrementByActiveElementCount(int value, Vector<uint> from); ++ public static long SaturatingDecrementByActiveElementCount(int value, Vector<ulong> from); ++ public static long SaturatingDecrementByActiveElementCount(long value, Vector<byte> from); ++ public static long SaturatingDecrementByActiveElementCount(long value, Vector<ushort> from); ++ public static long SaturatingDecrementByActiveElementCount(long value, Vector<uint> from); ++ public static long SaturatingDecrementByActiveElementCount(long value, Vector<ulong> from); ++ public static Vector<short> SaturatingDecrementByActiveElementCount(Vector<short> value, Vector<short> from); ++ public static Vector<int> SaturatingDecrementByActiveElementCount(Vector<int> value, Vector<int> from); ++ public static Vector<long> SaturatingDecrementByActiveElementCount(Vector<long> value, Vector<long> from); ++ public static Vector<ushort> SaturatingDecrementByActiveElementCount(Vector<ushort> value, Vector<ushort> from); ++ public static Vector<uint> SaturatingDecrementByActiveElementCount(Vector<uint> value, Vector<uint> from); ++ public static Vector<ulong> SaturatingDecrementByActiveElementCount(Vector<ulong> value, Vector<ulong> from); ++ public static ulong SaturatingDecrementByActiveElementCount(uint value, Vector<byte> from); ++ public static ulong SaturatingDecrementByActiveElementCount(uint value, Vector<ushort> from); ++ public static ulong SaturatingDecrementByActiveElementCount(uint value, Vector<uint> from); ++ public static ulong SaturatingDecrementByActiveElementCount(uint value, Vector<ulong> from); ++ public static ulong SaturatingDecrementByActiveElementCount(ulong value, Vector<byte> from); ++ public static ulong SaturatingDecrementByActiveElementCount(ulong value, Vector<ushort> from); ++ public static ulong SaturatingDecrementByActiveElementCount(ulong value, Vector<uint> from); ++ public static ulong SaturatingDecrementByActiveElementCount(ulong value, Vector<ulong> from); ++ public static int SaturatingIncrementBy16BitElementCount(int value, byte scale, SveMaskPattern pattern = SveMaskPattern.All); ++ public static long SaturatingIncrementBy16BitElementCount(long value, byte scale, SveMaskPattern pattern = SveMaskPattern.All); ++ public static Vector<short> SaturatingIncrementBy16BitElementCount(Vector<short> value, byte scale, SveMaskPattern pattern = SveMaskPattern.All); ++ public static Vector<ushort> SaturatingIncrementBy16BitElementCount(Vector<ushort> value, byte scale, SveMaskPattern pattern = SveMaskPattern.All); ++ public static uint SaturatingIncrementBy16BitElementCount(uint value, byte scale, SveMaskPattern pattern = SveMaskPattern.All); ++ public static ulong SaturatingIncrementBy16BitElementCount(ulong value, byte scale, SveMaskPattern pattern = SveMaskPattern.All); ++ public static int SaturatingIncrementBy32BitElementCount(int value, byte scale, SveMaskPattern pattern = SveMaskPattern.All); ++ public static long SaturatingIncrementBy32BitElementCount(long value, byte scale, SveMaskPattern pattern = SveMaskPattern.All); ++ public static Vector<int> SaturatingIncrementBy32BitElementCount(Vector<int> value, byte scale, SveMaskPattern pattern = SveMaskPattern.All); ++ public static Vector<uint> SaturatingIncrementBy32BitElementCount(Vector<uint> value, byte scale, SveMaskPattern pattern = SveMaskPattern.All); ++ public static uint SaturatingIncrementBy32BitElementCount(uint value, byte scale, SveMaskPattern pattern = SveMaskPattern.All); ++ public static ulong SaturatingIncrementBy32BitElementCount(ulong value, byte scale, SveMaskPattern pattern = SveMaskPattern.All); ++ public static int SaturatingIncrementBy64BitElementCount(int value, byte scale, SveMaskPattern pattern = SveMaskPattern.All); ++ public static long SaturatingIncrementBy64BitElementCount(long value, byte scale, SveMaskPattern pattern = SveMaskPattern.All); ++ public static Vector<long> SaturatingIncrementBy64BitElementCount(Vector<long> value, byte scale, SveMaskPattern pattern = SveMaskPattern.All); ++ public static Vector<ulong> SaturatingIncrementBy64BitElementCount(Vector<ulong> value, byte scale, SveMaskPattern pattern = SveMaskPattern.All); ++ public static uint SaturatingIncrementBy64BitElementCount(uint value, byte scale, SveMaskPattern pattern = SveMaskPattern.All); ++ public static ulong SaturatingIncrementBy64BitElementCount(ulong value, byte scale, SveMaskPattern pattern = SveMaskPattern.All); ++ public static int SaturatingIncrementBy8BitElementCount(int value, byte scale, SveMaskPattern pattern = SveMaskPattern.All); ++ public static long SaturatingIncrementBy8BitElementCount(long value, byte scale, SveMaskPattern pattern = SveMaskPattern.All); ++ public static uint SaturatingIncrementBy8BitElementCount(uint value, byte scale, SveMaskPattern pattern = SveMaskPattern.All); ++ public static ulong SaturatingIncrementBy8BitElementCount(ulong value, byte scale, SveMaskPattern pattern = SveMaskPattern.All); ++ public static long SaturatingIncrementByActiveElementCount(int value, Vector<byte> from); ++ public static long SaturatingIncrementByActiveElementCount(int value, Vector<ushort> from); ++ public static long SaturatingIncrementByActiveElementCount(int value, Vector<uint> from); ++ public static long SaturatingIncrementByActiveElementCount(int value, Vector<ulong> from); ++ public static long SaturatingIncrementByActiveElementCount(long value, Vector<byte> from); ++ public static long SaturatingIncrementByActiveElementCount(long value, Vector<ushort> from); ++ public static long SaturatingIncrementByActiveElementCount(long value, Vector<uint> from); ++ public static long SaturatingIncrementByActiveElementCount(long value, Vector<ulong> from); ++ public static Vector<short> SaturatingIncrementByActiveElementCount(Vector<short> value, Vector<short> from); ++ public static Vector<int> SaturatingIncrementByActiveElementCount(Vector<int> value, Vector<int> from); ++ public static Vector<long> SaturatingIncrementByActiveElementCount(Vector<long> value, Vector<long> from); ++ public static Vector<ushort> SaturatingIncrementByActiveElementCount(Vector<ushort> value, Vector<ushort> from); ++ public static Vector<uint> SaturatingIncrementByActiveElementCount(Vector<uint> value, Vector<uint> from); ++ public static Vector<ulong> SaturatingIncrementByActiveElementCount(Vector<ulong> value, Vector<ulong> from); ++ public static ulong SaturatingIncrementByActiveElementCount(uint value, Vector<byte> from); ++ public static ulong SaturatingIncrementByActiveElementCount(uint value, Vector<ushort> from); ++ public static ulong SaturatingIncrementByActiveElementCount(uint value, Vector<uint> from); ++ public static ulong SaturatingIncrementByActiveElementCount(uint value, Vector<ulong> from); ++ public static ulong SaturatingIncrementByActiveElementCount(ulong value, Vector<byte> from); ++ public static ulong SaturatingIncrementByActiveElementCount(ulong value, Vector<ushort> from); ++ public static ulong SaturatingIncrementByActiveElementCount(ulong value, Vector<uint> from); ++ public static ulong SaturatingIncrementByActiveElementCount(ulong value, Vector<ulong> from); ++ public unsafe static void StoreNarrowing(Vector<short> mask, sbyte* address, Vector<short> data); ++ public unsafe static void StoreNarrowing(Vector<int> mask, short* address, Vector<int> data); ++ public unsafe static void StoreNarrowing(Vector<int> mask, sbyte* address, Vector<int> data); ++ public unsafe static void StoreNarrowing(Vector<long> mask, short* address, Vector<long> data); ++ public unsafe static void StoreNarrowing(Vector<long> mask, int* address, Vector<long> data); ++ public unsafe static void StoreNarrowing(Vector<long> mask, sbyte* address, Vector<long> data); ++ public unsafe static void StoreNarrowing(Vector<ushort> mask, byte* address, Vector<ushort> data); ++ public unsafe static void StoreNarrowing(Vector<uint> mask, byte* address, Vector<uint> data); ++ public unsafe static void StoreNarrowing(Vector<uint> mask, ushort* address, Vector<uint> data); ++ public unsafe static void StoreNarrowing(Vector<ulong> mask, byte* address, Vector<ulong> data); ++ public unsafe static void StoreNarrowing(Vector<ulong> mask, ushort* address, Vector<ulong> data); ++ public unsafe static void StoreNarrowing(Vector<ulong> mask, uint* address, Vector<ulong> data); ++ public unsafe static void StoreNonTemporal(Vector<byte> mask, byte* address, Vector<byte> data); ++ public unsafe static void StoreNonTemporal(Vector<double> mask, double* address, Vector<double> data); ++ public unsafe static void StoreNonTemporal(Vector<short> mask, short* address, Vector<short> data); ++ public unsafe static void StoreNonTemporal(Vector<int> mask, int* address, Vector<int> data); ++ public unsafe static void StoreNonTemporal(Vector<long> mask, long* address, Vector<long> data); ++ public unsafe static void StoreNonTemporal(Vector<sbyte> mask, sbyte* address, Vector<sbyte> data); ++ public unsafe static void StoreNonTemporal(Vector<float> mask, float* address, Vector<float> data); ++ public unsafe static void StoreNonTemporal(Vector<ushort> mask, ushort* address, Vector<ushort> data); ++ public unsafe static void StoreNonTemporal(Vector<uint> mask, uint* address, Vector<uint> data); ++ public unsafe static void StoreNonTemporal(Vector<ulong> mask, ulong* address, Vector<ulong> data); ++ public static Vector<byte> TransposeEven(Vector<byte> left, Vector<byte> right); ++ public static Vector<double> TransposeEven(Vector<double> left, Vector<double> right); ++ public static Vector<short> TransposeEven(Vector<short> left, Vector<short> right); ++ public static Vector<int> TransposeEven(Vector<int> left, Vector<int> right); ++ public static Vector<long> TransposeEven(Vector<long> left, Vector<long> right); ++ public static Vector<sbyte> TransposeEven(Vector<sbyte> left, Vector<sbyte> right); ++ public static Vector<float> TransposeEven(Vector<float> left, Vector<float> right); ++ public static Vector<ushort> TransposeEven(Vector<ushort> left, Vector<ushort> right); ++ public static Vector<uint> TransposeEven(Vector<uint> left, Vector<uint> right); ++ public static Vector<ulong> TransposeEven(Vector<ulong> left, Vector<ulong> right); ++ public static Vector<byte> TransposeOdd(Vector<byte> left, Vector<byte> right); ++ public static Vector<double> TransposeOdd(Vector<double> left, Vector<double> right); ++ public static Vector<short> TransposeOdd(Vector<short> left, Vector<short> right); ++ public static Vector<int> TransposeOdd(Vector<int> left, Vector<int> right); ++ public static Vector<long> TransposeOdd(Vector<long> left, Vector<long> right); ++ public static Vector<sbyte> TransposeOdd(Vector<sbyte> left, Vector<sbyte> right); ++ public static Vector<float> TransposeOdd(Vector<float> left, Vector<float> right); ++ public static Vector<ushort> TransposeOdd(Vector<ushort> left, Vector<ushort> right); ++ public static Vector<uint> TransposeOdd(Vector<uint> left, Vector<uint> right); ++ public static Vector<ulong> TransposeOdd(Vector<ulong> left, Vector<ulong> right); + } ++ public enum SvePrefetchType : byte { ++ LoadL1NonTemporal = (byte)1, ++ LoadL1Temporal = (byte)0, ++ LoadL2NonTemporal = (byte)3, ++ LoadL2Temporal = (byte)2, ++ LoadL3NonTemporal = (byte)5, ++ LoadL3Temporal = (byte)4, ++ StoreL1NonTemporal = (byte)9, ++ StoreL1Temporal = (byte)8, ++ StoreL2NonTemporal = (byte)11, ++ StoreL2Temporal = (byte)10, ++ StoreL3NonTemporal = (byte)13, ++ StoreL3Temporal = (byte)12, ++ } + } +``` + diff --git a/release-notes/9.0/preview/preview6/api-diff/Microsoft.NETCore.App/9.0-preview6_System.Runtime.Intrinsics.X86.md b/release-notes/9.0/preview/preview6/api-diff/Microsoft.NETCore.App/9.0-preview6_System.Runtime.Intrinsics.X86.md new file mode 100644 index 0000000000..6b776e21b9 --- /dev/null +++ b/release-notes/9.0/preview/preview6/api-diff/Microsoft.NETCore.App/9.0-preview6_System.Runtime.Intrinsics.X86.md @@ -0,0 +1,545 @@ +# System.Runtime.Intrinsics.X86 + +``` diff + namespace System.Runtime.Intrinsics.X86 { ++ public abstract class Avx10v1 : Avx2 { ++ public static new bool IsSupported { get; } ++ public static Vector128<ulong> Abs(Vector128<long> value); ++ public static Vector256<ulong> Abs(Vector256<long> value); ++ public static Vector128<double> AddScalar(Vector128<double> left, Vector128<double> right, FloatRoundingMode mode); ++ public static Vector128<float> AddScalar(Vector128<float> left, Vector128<float> right, FloatRoundingMode mode); ++ public static Vector128<int> AlignRight32(Vector128<int> left, Vector128<int> right, byte mask); ++ public static Vector128<uint> AlignRight32(Vector128<uint> left, Vector128<uint> right, byte mask); ++ public static Vector256<int> AlignRight32(Vector256<int> left, Vector256<int> right, byte mask); ++ public static Vector256<uint> AlignRight32(Vector256<uint> left, Vector256<uint> right, byte mask); ++ public static Vector128<long> AlignRight64(Vector128<long> left, Vector128<long> right, byte mask); ++ public static Vector128<ulong> AlignRight64(Vector128<ulong> left, Vector128<ulong> right, byte mask); ++ public static Vector256<long> AlignRight64(Vector256<long> left, Vector256<long> right, byte mask); ++ public static Vector256<ulong> AlignRight64(Vector256<ulong> left, Vector256<ulong> right, byte mask); ++ public static Vector128<int> BroadcastPairScalarToVector128(Vector128<int> value); ++ public static Vector128<uint> BroadcastPairScalarToVector128(Vector128<uint> value); ++ public static Vector256<int> BroadcastPairScalarToVector256(Vector128<int> value); ++ public static Vector256<float> BroadcastPairScalarToVector256(Vector128<float> value); ++ public static Vector256<uint> BroadcastPairScalarToVector256(Vector128<uint> value); ++ public static Vector128<byte> CompareGreaterThan(Vector128<byte> left, Vector128<byte> right); ++ public static Vector128<ushort> CompareGreaterThan(Vector128<ushort> left, Vector128<ushort> right); ++ public static Vector128<uint> CompareGreaterThan(Vector128<uint> left, Vector128<uint> right); ++ public static Vector128<ulong> CompareGreaterThan(Vector128<ulong> left, Vector128<ulong> right); ++ public static Vector256<byte> CompareGreaterThan(Vector256<byte> left, Vector256<byte> right); ++ public static Vector256<ushort> CompareGreaterThan(Vector256<ushort> left, Vector256<ushort> right); ++ public static Vector256<uint> CompareGreaterThan(Vector256<uint> left, Vector256<uint> right); ++ public static Vector256<ulong> CompareGreaterThan(Vector256<ulong> left, Vector256<ulong> right); ++ public static Vector128<byte> CompareGreaterThanOrEqual(Vector128<byte> left, Vector128<byte> right); ++ public static Vector128<short> CompareGreaterThanOrEqual(Vector128<short> left, Vector128<short> right); ++ public static Vector128<int> CompareGreaterThanOrEqual(Vector128<int> left, Vector128<int> right); ++ public static Vector128<long> CompareGreaterThanOrEqual(Vector128<long> left, Vector128<long> right); ++ public static Vector128<sbyte> CompareGreaterThanOrEqual(Vector128<sbyte> left, Vector128<sbyte> right); ++ public static Vector128<ushort> CompareGreaterThanOrEqual(Vector128<ushort> left, Vector128<ushort> right); ++ public static Vector128<uint> CompareGreaterThanOrEqual(Vector128<uint> left, Vector128<uint> right); ++ public static Vector128<ulong> CompareGreaterThanOrEqual(Vector128<ulong> left, Vector128<ulong> right); ++ public static Vector256<byte> CompareGreaterThanOrEqual(Vector256<byte> left, Vector256<byte> right); ++ public static Vector256<short> CompareGreaterThanOrEqual(Vector256<short> left, Vector256<short> right); ++ public static Vector256<int> CompareGreaterThanOrEqual(Vector256<int> left, Vector256<int> right); ++ public static Vector256<long> CompareGreaterThanOrEqual(Vector256<long> left, Vector256<long> right); ++ public static Vector256<sbyte> CompareGreaterThanOrEqual(Vector256<sbyte> left, Vector256<sbyte> right); ++ public static Vector256<ushort> CompareGreaterThanOrEqual(Vector256<ushort> left, Vector256<ushort> right); ++ public static Vector256<uint> CompareGreaterThanOrEqual(Vector256<uint> left, Vector256<uint> right); ++ public static Vector256<ulong> CompareGreaterThanOrEqual(Vector256<ulong> left, Vector256<ulong> right); ++ public static Vector128<byte> CompareLessThan(Vector128<byte> left, Vector128<byte> right); ++ public static new Vector128<short> CompareLessThan(Vector128<short> left, Vector128<short> right); ++ public static new Vector128<int> CompareLessThan(Vector128<int> left, Vector128<int> right); ++ public static Vector128<long> CompareLessThan(Vector128<long> left, Vector128<long> right); ++ public static new Vector128<sbyte> CompareLessThan(Vector128<sbyte> left, Vector128<sbyte> right); ++ public static Vector128<ushort> CompareLessThan(Vector128<ushort> left, Vector128<ushort> right); ++ public static Vector128<uint> CompareLessThan(Vector128<uint> left, Vector128<uint> right); ++ public static Vector128<ulong> CompareLessThan(Vector128<ulong> left, Vector128<ulong> right); ++ public static Vector256<byte> CompareLessThan(Vector256<byte> left, Vector256<byte> right); ++ public static Vector256<short> CompareLessThan(Vector256<short> left, Vector256<short> right); ++ public static Vector256<int> CompareLessThan(Vector256<int> left, Vector256<int> right); ++ public static Vector256<long> CompareLessThan(Vector256<long> left, Vector256<long> right); ++ public static Vector256<sbyte> CompareLessThan(Vector256<sbyte> left, Vector256<sbyte> right); ++ public static Vector256<ushort> CompareLessThan(Vector256<ushort> left, Vector256<ushort> right); ++ public static Vector256<uint> CompareLessThan(Vector256<uint> left, Vector256<uint> right); ++ public static Vector256<ulong> CompareLessThan(Vector256<ulong> left, Vector256<ulong> right); ++ public static Vector128<byte> CompareLessThanOrEqual(Vector128<byte> left, Vector128<byte> right); ++ public static Vector128<short> CompareLessThanOrEqual(Vector128<short> left, Vector128<short> right); ++ public static Vector128<int> CompareLessThanOrEqual(Vector128<int> left, Vector128<int> right); ++ public static Vector128<long> CompareLessThanOrEqual(Vector128<long> left, Vector128<long> right); ++ public static Vector128<sbyte> CompareLessThanOrEqual(Vector128<sbyte> left, Vector128<sbyte> right); ++ public static Vector128<ushort> CompareLessThanOrEqual(Vector128<ushort> left, Vector128<ushort> right); ++ public static Vector128<uint> CompareLessThanOrEqual(Vector128<uint> left, Vector128<uint> right); ++ public static Vector128<ulong> CompareLessThanOrEqual(Vector128<ulong> left, Vector128<ulong> right); ++ public static Vector256<byte> CompareLessThanOrEqual(Vector256<byte> left, Vector256<byte> right); ++ public static Vector256<short> CompareLessThanOrEqual(Vector256<short> left, Vector256<short> right); ++ public static Vector256<int> CompareLessThanOrEqual(Vector256<int> left, Vector256<int> right); ++ public static Vector256<long> CompareLessThanOrEqual(Vector256<long> left, Vector256<long> right); ++ public static Vector256<sbyte> CompareLessThanOrEqual(Vector256<sbyte> left, Vector256<sbyte> right); ++ public static Vector256<ushort> CompareLessThanOrEqual(Vector256<ushort> left, Vector256<ushort> right); ++ public static Vector256<uint> CompareLessThanOrEqual(Vector256<uint> left, Vector256<uint> right); ++ public static Vector256<ulong> CompareLessThanOrEqual(Vector256<ulong> left, Vector256<ulong> right); ++ public static Vector128<byte> CompareNotEqual(Vector128<byte> left, Vector128<byte> right); ++ public static Vector128<short> CompareNotEqual(Vector128<short> left, Vector128<short> right); ++ public static Vector128<int> CompareNotEqual(Vector128<int> left, Vector128<int> right); ++ public static Vector128<long> CompareNotEqual(Vector128<long> left, Vector128<long> right); ++ public static Vector128<sbyte> CompareNotEqual(Vector128<sbyte> left, Vector128<sbyte> right); ++ public static Vector128<ushort> CompareNotEqual(Vector128<ushort> left, Vector128<ushort> right); ++ public static Vector128<uint> CompareNotEqual(Vector128<uint> left, Vector128<uint> right); ++ public static Vector128<ulong> CompareNotEqual(Vector128<ulong> left, Vector128<ulong> right); ++ public static Vector256<byte> CompareNotEqual(Vector256<byte> left, Vector256<byte> right); ++ public static Vector256<short> CompareNotEqual(Vector256<short> left, Vector256<short> right); ++ public static Vector256<int> CompareNotEqual(Vector256<int> left, Vector256<int> right); ++ public static Vector256<long> CompareNotEqual(Vector256<long> left, Vector256<long> right); ++ public static Vector256<sbyte> CompareNotEqual(Vector256<sbyte> left, Vector256<sbyte> right); ++ public static Vector256<ushort> CompareNotEqual(Vector256<ushort> left, Vector256<ushort> right); ++ public static Vector256<uint> CompareNotEqual(Vector256<uint> left, Vector256<uint> right); ++ public static Vector256<ulong> CompareNotEqual(Vector256<ulong> left, Vector256<ulong> right); ++ public static Vector128<double> ConvertScalarToVector128Double(Vector128<double> upper, uint value); ++ public static Vector128<float> ConvertScalarToVector128Single(Vector128<float> upper, int value, FloatRoundingMode mode); ++ public static Vector128<float> ConvertScalarToVector128Single(Vector128<float> upper, Vector128<double> value, FloatRoundingMode mode); ++ public static Vector128<float> ConvertScalarToVector128Single(Vector128<float> upper, uint value); ++ public static Vector128<float> ConvertScalarToVector128Single(Vector128<float> upper, uint value, FloatRoundingMode mode); ++ public static int ConvertToInt32(Vector128<double> value, FloatRoundingMode mode); ++ public static int ConvertToInt32(Vector128<float> value, FloatRoundingMode mode); ++ public static uint ConvertToUInt32(Vector128<double> value); ++ public static uint ConvertToUInt32(Vector128<double> value, FloatRoundingMode mode); ++ public static uint ConvertToUInt32(Vector128<float> value); ++ public static uint ConvertToUInt32(Vector128<float> value, FloatRoundingMode mode); ++ public static uint ConvertToUInt32WithTruncation(Vector128<double> value); ++ public static uint ConvertToUInt32WithTruncation(Vector128<float> value); ++ public static Vector128<byte> ConvertToVector128Byte(Vector128<short> value); ++ public static Vector128<byte> ConvertToVector128Byte(Vector128<int> value); ++ public static Vector128<byte> ConvertToVector128Byte(Vector128<long> value); ++ public static Vector128<byte> ConvertToVector128Byte(Vector128<ushort> value); ++ public static Vector128<byte> ConvertToVector128Byte(Vector128<uint> value); ++ public static Vector128<byte> ConvertToVector128Byte(Vector128<ulong> value); ++ public static Vector128<byte> ConvertToVector128Byte(Vector256<short> value); ++ public static Vector128<byte> ConvertToVector128Byte(Vector256<int> value); ++ public static Vector128<byte> ConvertToVector128Byte(Vector256<long> value); ++ public static Vector128<byte> ConvertToVector128Byte(Vector256<ushort> value); ++ public static Vector128<byte> ConvertToVector128Byte(Vector256<uint> value); ++ public static Vector128<byte> ConvertToVector128Byte(Vector256<ulong> value); ++ public static Vector128<byte> ConvertToVector128ByteWithSaturation(Vector128<ushort> value); ++ public static Vector128<byte> ConvertToVector128ByteWithSaturation(Vector128<uint> value); ++ public static Vector128<byte> ConvertToVector128ByteWithSaturation(Vector128<ulong> value); ++ public static Vector128<byte> ConvertToVector128ByteWithSaturation(Vector256<ushort> value); ++ public static Vector128<byte> ConvertToVector128ByteWithSaturation(Vector256<uint> value); ++ public static Vector128<byte> ConvertToVector128ByteWithSaturation(Vector256<ulong> value); ++ public static Vector128<double> ConvertToVector128Double(Vector128<long> value); ++ public static Vector128<double> ConvertToVector128Double(Vector128<uint> value); ++ public static Vector128<double> ConvertToVector128Double(Vector128<ulong> value); ++ public static Vector128<short> ConvertToVector128Int16(Vector128<int> value); ++ public static Vector128<short> ConvertToVector128Int16(Vector128<long> value); ++ public static Vector128<short> ConvertToVector128Int16(Vector128<uint> value); ++ public static Vector128<short> ConvertToVector128Int16(Vector128<ulong> value); ++ public static Vector128<short> ConvertToVector128Int16(Vector256<int> value); ++ public static Vector128<short> ConvertToVector128Int16(Vector256<long> value); ++ public static Vector128<short> ConvertToVector128Int16(Vector256<uint> value); ++ public static Vector128<short> ConvertToVector128Int16(Vector256<ulong> value); ++ public static Vector128<short> ConvertToVector128Int16WithSaturation(Vector128<int> value); ++ public static Vector128<short> ConvertToVector128Int16WithSaturation(Vector128<long> value); ++ public static Vector128<short> ConvertToVector128Int16WithSaturation(Vector256<int> value); ++ public static Vector128<short> ConvertToVector128Int16WithSaturation(Vector256<long> value); ++ public static Vector128<int> ConvertToVector128Int32(Vector128<long> value); ++ public static Vector128<int> ConvertToVector128Int32(Vector128<ulong> value); ++ public static Vector128<int> ConvertToVector128Int32(Vector256<long> value); ++ public static Vector128<int> ConvertToVector128Int32(Vector256<ulong> value); ++ public static Vector128<int> ConvertToVector128Int32WithSaturation(Vector128<long> value); ++ public static Vector128<int> ConvertToVector128Int32WithSaturation(Vector256<long> value); ++ public static Vector128<long> ConvertToVector128Int64(Vector128<double> value); ++ public static Vector128<long> ConvertToVector128Int64(Vector128<float> value); ++ public static Vector128<long> ConvertToVector128Int64WithTruncation(Vector128<double> value); ++ public static Vector128<long> ConvertToVector128Int64WithTruncation(Vector128<float> value); ++ public static Vector128<sbyte> ConvertToVector128SByte(Vector128<short> value); ++ public static Vector128<sbyte> ConvertToVector128SByte(Vector128<int> value); ++ public static Vector128<sbyte> ConvertToVector128SByte(Vector128<long> value); ++ public static Vector128<sbyte> ConvertToVector128SByte(Vector128<ushort> value); ++ public static Vector128<sbyte> ConvertToVector128SByte(Vector128<uint> value); ++ public static Vector128<sbyte> ConvertToVector128SByte(Vector128<ulong> value); ++ public static Vector128<sbyte> ConvertToVector128SByte(Vector256<short> value); ++ public static Vector128<sbyte> ConvertToVector128SByte(Vector256<int> value); ++ public static Vector128<sbyte> ConvertToVector128SByte(Vector256<long> value); ++ public static Vector128<sbyte> ConvertToVector128SByte(Vector256<ushort> value); ++ public static Vector128<sbyte> ConvertToVector128SByte(Vector256<uint> value); ++ public static Vector128<sbyte> ConvertToVector128SByte(Vector256<ulong> value); ++ public static Vector128<sbyte> ConvertToVector128SByteWithSaturation(Vector128<short> value); ++ public static Vector128<sbyte> ConvertToVector128SByteWithSaturation(Vector128<int> value); ++ public static Vector128<sbyte> ConvertToVector128SByteWithSaturation(Vector128<long> value); ++ public static Vector128<sbyte> ConvertToVector128SByteWithSaturation(Vector256<short> value); ++ public static Vector128<sbyte> ConvertToVector128SByteWithSaturation(Vector256<int> value); ++ public static Vector128<sbyte> ConvertToVector128SByteWithSaturation(Vector256<long> value); ++ public static Vector128<float> ConvertToVector128Single(Vector128<long> value); ++ public static Vector128<float> ConvertToVector128Single(Vector128<uint> value); ++ public static Vector128<float> ConvertToVector128Single(Vector128<ulong> value); ++ public static Vector128<float> ConvertToVector128Single(Vector256<long> value); ++ public static Vector128<float> ConvertToVector128Single(Vector256<ulong> value); ++ public static Vector128<ushort> ConvertToVector128UInt16(Vector128<int> value); ++ public static Vector128<ushort> ConvertToVector128UInt16(Vector128<long> value); ++ public static Vector128<ushort> ConvertToVector128UInt16(Vector128<uint> value); ++ public static Vector128<ushort> ConvertToVector128UInt16(Vector128<ulong> value); ++ public static Vector128<ushort> ConvertToVector128UInt16(Vector256<int> value); ++ public static Vector128<ushort> ConvertToVector128UInt16(Vector256<long> value); ++ public static Vector128<ushort> ConvertToVector128UInt16(Vector256<uint> value); ++ public static Vector128<ushort> ConvertToVector128UInt16(Vector256<ulong> value); ++ public static Vector128<ushort> ConvertToVector128UInt16WithSaturation(Vector128<uint> value); ++ public static Vector128<ushort> ConvertToVector128UInt16WithSaturation(Vector128<ulong> value); ++ public static Vector128<ushort> ConvertToVector128UInt16WithSaturation(Vector256<uint> value); ++ public static Vector128<ushort> ConvertToVector128UInt16WithSaturation(Vector256<ulong> value); ++ public static Vector128<uint> ConvertToVector128UInt32(Vector128<double> value); ++ public static Vector128<uint> ConvertToVector128UInt32(Vector128<long> value); ++ public static Vector128<uint> ConvertToVector128UInt32(Vector128<float> value); ++ public static Vector128<uint> ConvertToVector128UInt32(Vector128<ulong> value); ++ public static Vector128<uint> ConvertToVector128UInt32(Vector256<double> value); ++ public static Vector128<uint> ConvertToVector128UInt32(Vector256<long> value); ++ public static Vector128<uint> ConvertToVector128UInt32(Vector256<ulong> value); ++ public static Vector128<uint> ConvertToVector128UInt32WithSaturation(Vector128<ulong> value); ++ public static Vector128<uint> ConvertToVector128UInt32WithSaturation(Vector256<ulong> value); ++ public static Vector128<uint> ConvertToVector128UInt32WithTruncation(Vector128<double> value); ++ public static Vector128<uint> ConvertToVector128UInt32WithTruncation(Vector128<float> value); ++ public static Vector128<uint> ConvertToVector128UInt32WithTruncation(Vector256<double> value); ++ public static Vector128<ulong> ConvertToVector128UInt64(Vector128<double> value); ++ public static Vector128<ulong> ConvertToVector128UInt64(Vector128<float> value); ++ public static Vector128<ulong> ConvertToVector128UInt64WithTruncation(Vector128<double> value); ++ public static Vector128<ulong> ConvertToVector128UInt64WithTruncation(Vector128<float> value); ++ public static Vector256<double> ConvertToVector256Double(Vector128<uint> value); ++ public static Vector256<double> ConvertToVector256Double(Vector256<long> value); ++ public static Vector256<double> ConvertToVector256Double(Vector256<ulong> value); ++ public static Vector256<long> ConvertToVector256Int64(Vector128<float> value); ++ public static Vector256<long> ConvertToVector256Int64(Vector256<double> value); ++ public static Vector256<long> ConvertToVector256Int64WithTruncation(Vector128<float> value); ++ public static Vector256<long> ConvertToVector256Int64WithTruncation(Vector256<double> value); ++ public static Vector256<float> ConvertToVector256Single(Vector256<uint> value); ++ public static Vector256<uint> ConvertToVector256UInt32(Vector256<float> value); ++ public static Vector256<uint> ConvertToVector256UInt32WithTruncation(Vector256<float> value); ++ public static Vector256<ulong> ConvertToVector256UInt64(Vector128<float> value); ++ public static Vector256<ulong> ConvertToVector256UInt64(Vector256<double> value); ++ public static Vector256<ulong> ConvertToVector256UInt64WithTruncation(Vector128<float> value); ++ public static Vector256<ulong> ConvertToVector256UInt64WithTruncation(Vector256<double> value); ++ public static Vector128<int> DetectConflicts(Vector128<int> value); ++ public static Vector128<long> DetectConflicts(Vector128<long> value); ++ public static Vector128<uint> DetectConflicts(Vector128<uint> value); ++ public static Vector128<ulong> DetectConflicts(Vector128<ulong> value); ++ public static Vector256<int> DetectConflicts(Vector256<int> value); ++ public static Vector256<long> DetectConflicts(Vector256<long> value); ++ public static Vector256<uint> DetectConflicts(Vector256<uint> value); ++ public static Vector256<ulong> DetectConflicts(Vector256<ulong> value); ++ public static Vector128<double> DivideScalar(Vector128<double> left, Vector128<double> right, FloatRoundingMode mode); ++ public static Vector128<float> DivideScalar(Vector128<float> left, Vector128<float> right, FloatRoundingMode mode); ++ public static Vector128<double> Fixup(Vector128<double> left, Vector128<double> right, Vector128<long> table, byte control); ++ public static Vector128<float> Fixup(Vector128<float> left, Vector128<float> right, Vector128<int> table, byte control); ++ public static Vector256<double> Fixup(Vector256<double> left, Vector256<double> right, Vector256<long> table, byte control); ++ public static Vector256<float> Fixup(Vector256<float> left, Vector256<float> right, Vector256<int> table, byte control); ++ public static Vector128<double> FixupScalar(Vector128<double> left, Vector128<double> right, Vector128<long> table, byte control); ++ public static Vector128<float> FixupScalar(Vector128<float> left, Vector128<float> right, Vector128<int> table, byte control); ++ public static Vector128<double> FusedMultiplyAddNegatedScalar(Vector128<double> a, Vector128<double> b, Vector128<double> c, FloatRoundingMode mode); ++ public static Vector128<float> FusedMultiplyAddNegatedScalar(Vector128<float> a, Vector128<float> b, Vector128<float> c, FloatRoundingMode mode); ++ public static Vector128<double> FusedMultiplyAddScalar(Vector128<double> a, Vector128<double> b, Vector128<double> c, FloatRoundingMode mode); ++ public static Vector128<float> FusedMultiplyAddScalar(Vector128<float> a, Vector128<float> b, Vector128<float> c, FloatRoundingMode mode); ++ public static Vector128<double> FusedMultiplySubtractNegatedScalar(Vector128<double> a, Vector128<double> b, Vector128<double> c, FloatRoundingMode mode); ++ public static Vector128<float> FusedMultiplySubtractNegatedScalar(Vector128<float> a, Vector128<float> b, Vector128<float> c, FloatRoundingMode mode); ++ public static Vector128<double> FusedMultiplySubtractScalar(Vector128<double> a, Vector128<double> b, Vector128<double> c, FloatRoundingMode mode); ++ public static Vector128<float> FusedMultiplySubtractScalar(Vector128<float> a, Vector128<float> b, Vector128<float> c, FloatRoundingMode mode); ++ public static Vector128<double> GetExponent(Vector128<double> value); ++ public static Vector128<float> GetExponent(Vector128<float> value); ++ public static Vector256<double> GetExponent(Vector256<double> value); ++ public static Vector256<float> GetExponent(Vector256<float> value); ++ public static Vector128<double> GetExponentScalar(Vector128<double> value); ++ public static Vector128<double> GetExponentScalar(Vector128<double> upper, Vector128<double> value); ++ public static Vector128<float> GetExponentScalar(Vector128<float> value); ++ public static Vector128<float> GetExponentScalar(Vector128<float> upper, Vector128<float> value); ++ public static Vector128<double> GetMantissa(Vector128<double> value, byte control); ++ public static Vector128<float> GetMantissa(Vector128<float> value, byte control); ++ public static Vector256<double> GetMantissa(Vector256<double> value, byte control); ++ public static Vector256<float> GetMantissa(Vector256<float> value, byte control); ++ public static Vector128<double> GetMantissaScalar(Vector128<double> value, byte control); ++ public static Vector128<double> GetMantissaScalar(Vector128<double> upper, Vector128<double> value, byte control); ++ public static Vector128<float> GetMantissaScalar(Vector128<float> value, byte control); ++ public static Vector128<float> GetMantissaScalar(Vector128<float> upper, Vector128<float> value, byte control); ++ public static Vector128<int> LeadingZeroCount(Vector128<int> value); ++ public static Vector128<long> LeadingZeroCount(Vector128<long> value); ++ public static Vector128<uint> LeadingZeroCount(Vector128<uint> value); ++ public static Vector128<ulong> LeadingZeroCount(Vector128<ulong> value); ++ public static Vector256<int> LeadingZeroCount(Vector256<int> value); ++ public static Vector256<long> LeadingZeroCount(Vector256<long> value); ++ public static Vector256<uint> LeadingZeroCount(Vector256<uint> value); ++ public static Vector256<ulong> LeadingZeroCount(Vector256<ulong> value); ++ public static Vector128<long> Max(Vector128<long> left, Vector128<long> right); ++ public static Vector128<ulong> Max(Vector128<ulong> left, Vector128<ulong> right); ++ public static Vector256<long> Max(Vector256<long> left, Vector256<long> right); ++ public static Vector256<ulong> Max(Vector256<ulong> left, Vector256<ulong> right); ++ public static Vector128<long> Min(Vector128<long> left, Vector128<long> right); ++ public static Vector128<ulong> Min(Vector128<ulong> left, Vector128<ulong> right); ++ public static Vector256<long> Min(Vector256<long> left, Vector256<long> right); ++ public static Vector256<ulong> Min(Vector256<ulong> left, Vector256<ulong> right); ++ public static Vector128<long> MultiplyLow(Vector128<long> left, Vector128<long> right); ++ public static Vector128<ulong> MultiplyLow(Vector128<ulong> left, Vector128<ulong> right); ++ public static Vector256<long> MultiplyLow(Vector256<long> left, Vector256<long> right); ++ public static Vector256<ulong> MultiplyLow(Vector256<ulong> left, Vector256<ulong> right); ++ public static Vector128<double> MultiplyScalar(Vector128<double> left, Vector128<double> right, FloatRoundingMode mode); ++ public static Vector128<float> MultiplyScalar(Vector128<float> left, Vector128<float> right, FloatRoundingMode mode); ++ public static Vector128<byte> MultiShift(Vector128<byte> control, Vector128<ulong> value); ++ public static Vector128<sbyte> MultiShift(Vector128<sbyte> control, Vector128<long> value); ++ public static Vector256<byte> MultiShift(Vector256<byte> control, Vector256<ulong> value); ++ public static Vector256<sbyte> MultiShift(Vector256<sbyte> control, Vector256<long> value); ++ public static Vector256<short> PermuteVar16x16(Vector256<short> left, Vector256<short> control); ++ public static Vector256<ushort> PermuteVar16x16(Vector256<ushort> left, Vector256<ushort> control); ++ public static Vector256<short> PermuteVar16x16x2(Vector256<short> lower, Vector256<short> indices, Vector256<short> upper); ++ public static Vector256<ushort> PermuteVar16x16x2(Vector256<ushort> lower, Vector256<ushort> indices, Vector256<ushort> upper); ++ public static Vector128<byte> PermuteVar16x8(Vector128<byte> left, Vector128<byte> control); ++ public static Vector128<sbyte> PermuteVar16x8(Vector128<sbyte> left, Vector128<sbyte> control); ++ public static Vector128<byte> PermuteVar16x8x2(Vector128<byte> lower, Vector128<byte> indices, Vector128<byte> upper); ++ public static Vector128<sbyte> PermuteVar16x8x2(Vector128<sbyte> lower, Vector128<sbyte> indices, Vector128<sbyte> upper); ++ public static Vector128<double> PermuteVar2x64x2(Vector128<double> lower, Vector128<long> indices, Vector128<double> upper); ++ public static Vector128<long> PermuteVar2x64x2(Vector128<long> lower, Vector128<long> indices, Vector128<long> upper); ++ public static Vector128<ulong> PermuteVar2x64x2(Vector128<ulong> lower, Vector128<ulong> indices, Vector128<ulong> upper); ++ public static Vector256<byte> PermuteVar32x8(Vector256<byte> left, Vector256<byte> control); ++ public static Vector256<sbyte> PermuteVar32x8(Vector256<sbyte> left, Vector256<sbyte> control); ++ public static Vector256<byte> PermuteVar32x8x2(Vector256<byte> lower, Vector256<byte> indices, Vector256<byte> upper); ++ public static Vector256<sbyte> PermuteVar32x8x2(Vector256<sbyte> lower, Vector256<sbyte> indices, Vector256<sbyte> upper); ++ public static Vector128<int> PermuteVar4x32x2(Vector128<int> lower, Vector128<int> indices, Vector128<int> upper); ++ public static Vector128<float> PermuteVar4x32x2(Vector128<float> lower, Vector128<int> indices, Vector128<float> upper); ++ public static Vector128<uint> PermuteVar4x32x2(Vector128<uint> lower, Vector128<uint> indices, Vector128<uint> upper); ++ public static Vector256<double> PermuteVar4x64(Vector256<double> value, Vector256<long> control); ++ public static Vector256<long> PermuteVar4x64(Vector256<long> value, Vector256<long> control); ++ public static Vector256<ulong> PermuteVar4x64(Vector256<ulong> value, Vector256<ulong> control); ++ public static Vector256<double> PermuteVar4x64x2(Vector256<double> lower, Vector256<long> indices, Vector256<double> upper); ++ public static Vector256<long> PermuteVar4x64x2(Vector256<long> lower, Vector256<long> indices, Vector256<long> upper); ++ public static Vector256<ulong> PermuteVar4x64x2(Vector256<ulong> lower, Vector256<ulong> indices, Vector256<ulong> upper); ++ public static Vector128<short> PermuteVar8x16(Vector128<short> left, Vector128<short> control); ++ public static Vector128<ushort> PermuteVar8x16(Vector128<ushort> left, Vector128<ushort> control); ++ public static Vector128<short> PermuteVar8x16x2(Vector128<short> lower, Vector128<short> indices, Vector128<short> upper); ++ public static Vector128<ushort> PermuteVar8x16x2(Vector128<ushort> lower, Vector128<ushort> indices, Vector128<ushort> upper); ++ public static Vector256<int> PermuteVar8x32x2(Vector256<int> lower, Vector256<int> indices, Vector256<int> upper); ++ public static Vector256<float> PermuteVar8x32x2(Vector256<float> lower, Vector256<int> indices, Vector256<float> upper); ++ public static Vector256<uint> PermuteVar8x32x2(Vector256<uint> lower, Vector256<uint> indices, Vector256<uint> upper); ++ public static Vector128<double> Range(Vector128<double> left, Vector128<double> right, byte control); ++ public static Vector128<float> Range(Vector128<float> left, Vector128<float> right, byte control); ++ public static Vector256<double> Range(Vector256<double> left, Vector256<double> right, byte control); ++ public static Vector256<float> Range(Vector256<float> left, Vector256<float> right, byte control); ++ public static Vector128<double> RangeScalar(Vector128<double> left, Vector128<double> right, byte control); ++ public static Vector128<float> RangeScalar(Vector128<float> left, Vector128<float> right, byte control); ++ public static Vector128<double> Reciprocal14(Vector128<double> value); ++ public static Vector128<float> Reciprocal14(Vector128<float> value); ++ public static Vector256<double> Reciprocal14(Vector256<double> value); ++ public static Vector256<float> Reciprocal14(Vector256<float> value); ++ public static Vector128<double> Reciprocal14Scalar(Vector128<double> value); ++ public static Vector128<double> Reciprocal14Scalar(Vector128<double> upper, Vector128<double> value); ++ public static Vector128<float> Reciprocal14Scalar(Vector128<float> value); ++ public static Vector128<float> Reciprocal14Scalar(Vector128<float> upper, Vector128<float> value); ++ public static Vector128<double> ReciprocalSqrt14(Vector128<double> value); ++ public static Vector128<float> ReciprocalSqrt14(Vector128<float> value); ++ public static Vector256<double> ReciprocalSqrt14(Vector256<double> value); ++ public static Vector256<float> ReciprocalSqrt14(Vector256<float> value); ++ public static Vector128<double> ReciprocalSqrt14Scalar(Vector128<double> value); ++ public static Vector128<double> ReciprocalSqrt14Scalar(Vector128<double> upper, Vector128<double> value); ++ public static Vector128<float> ReciprocalSqrt14Scalar(Vector128<float> value); ++ public static Vector128<float> ReciprocalSqrt14Scalar(Vector128<float> upper, Vector128<float> value); ++ public static Vector128<double> Reduce(Vector128<double> value, byte control); ++ public static Vector128<float> Reduce(Vector128<float> value, byte control); ++ public static Vector256<double> Reduce(Vector256<double> value, byte control); ++ public static Vector256<float> Reduce(Vector256<float> value, byte control); ++ public static Vector128<double> ReduceScalar(Vector128<double> value, byte control); ++ public static Vector128<double> ReduceScalar(Vector128<double> upper, Vector128<double> value, byte control); ++ public static Vector128<float> ReduceScalar(Vector128<float> value, byte control); ++ public static Vector128<float> ReduceScalar(Vector128<float> upper, Vector128<float> value, byte control); ++ public static Vector128<int> RotateLeft(Vector128<int> value, byte count); ++ public static Vector128<long> RotateLeft(Vector128<long> value, byte count); ++ public static Vector128<uint> RotateLeft(Vector128<uint> value, byte count); ++ public static Vector128<ulong> RotateLeft(Vector128<ulong> value, byte count); ++ public static Vector256<int> RotateLeft(Vector256<int> value, byte count); ++ public static Vector256<long> RotateLeft(Vector256<long> value, byte count); ++ public static Vector256<uint> RotateLeft(Vector256<uint> value, byte count); ++ public static Vector256<ulong> RotateLeft(Vector256<ulong> value, byte count); ++ public static Vector128<int> RotateLeftVariable(Vector128<int> value, Vector128<uint> count); ++ public static Vector128<long> RotateLeftVariable(Vector128<long> value, Vector128<ulong> count); ++ public static Vector128<uint> RotateLeftVariable(Vector128<uint> value, Vector128<uint> count); ++ public static Vector128<ulong> RotateLeftVariable(Vector128<ulong> value, Vector128<ulong> count); ++ public static Vector256<int> RotateLeftVariable(Vector256<int> value, Vector256<uint> count); ++ public static Vector256<long> RotateLeftVariable(Vector256<long> value, Vector256<ulong> count); ++ public static Vector256<uint> RotateLeftVariable(Vector256<uint> value, Vector256<uint> count); ++ public static Vector256<ulong> RotateLeftVariable(Vector256<ulong> value, Vector256<ulong> count); ++ public static Vector128<int> RotateRight(Vector128<int> value, byte count); ++ public static Vector128<long> RotateRight(Vector128<long> value, byte count); ++ public static Vector128<uint> RotateRight(Vector128<uint> value, byte count); ++ public static Vector128<ulong> RotateRight(Vector128<ulong> value, byte count); ++ public static Vector256<int> RotateRight(Vector256<int> value, byte count); ++ public static Vector256<long> RotateRight(Vector256<long> value, byte count); ++ public static Vector256<uint> RotateRight(Vector256<uint> value, byte count); ++ public static Vector256<ulong> RotateRight(Vector256<ulong> value, byte count); ++ public static Vector128<int> RotateRightVariable(Vector128<int> value, Vector128<uint> count); ++ public static Vector128<long> RotateRightVariable(Vector128<long> value, Vector128<ulong> count); ++ public static Vector128<uint> RotateRightVariable(Vector128<uint> value, Vector128<uint> count); ++ public static Vector128<ulong> RotateRightVariable(Vector128<ulong> value, Vector128<ulong> count); ++ public static Vector256<int> RotateRightVariable(Vector256<int> value, Vector256<uint> count); ++ public static Vector256<long> RotateRightVariable(Vector256<long> value, Vector256<ulong> count); ++ public static Vector256<uint> RotateRightVariable(Vector256<uint> value, Vector256<uint> count); ++ public static Vector256<ulong> RotateRightVariable(Vector256<ulong> value, Vector256<ulong> count); ++ public static Vector128<double> RoundScale(Vector128<double> value, byte control); ++ public static Vector128<float> RoundScale(Vector128<float> value, byte control); ++ public static Vector256<double> RoundScale(Vector256<double> value, byte control); ++ public static Vector256<float> RoundScale(Vector256<float> value, byte control); ++ public static Vector128<double> RoundScaleScalar(Vector128<double> value, byte control); ++ public static Vector128<double> RoundScaleScalar(Vector128<double> upper, Vector128<double> value, byte control); ++ public static Vector128<float> RoundScaleScalar(Vector128<float> value, byte control); ++ public static Vector128<float> RoundScaleScalar(Vector128<float> upper, Vector128<float> value, byte control); ++ public static Vector128<double> Scale(Vector128<double> left, Vector128<double> right); ++ public static Vector128<float> Scale(Vector128<float> left, Vector128<float> right); ++ public static Vector256<double> Scale(Vector256<double> left, Vector256<double> right); ++ public static Vector256<float> Scale(Vector256<float> left, Vector256<float> right); ++ public static Vector128<double> ScaleScalar(Vector128<double> left, Vector128<double> right); ++ public static Vector128<double> ScaleScalar(Vector128<double> left, Vector128<double> right, FloatRoundingMode mode); ++ public static Vector128<float> ScaleScalar(Vector128<float> left, Vector128<float> right); ++ public static Vector128<float> ScaleScalar(Vector128<float> left, Vector128<float> right, FloatRoundingMode mode); ++ public static Vector128<short> ShiftLeftLogicalVariable(Vector128<short> value, Vector128<ushort> count); ++ public static Vector128<ushort> ShiftLeftLogicalVariable(Vector128<ushort> value, Vector128<ushort> count); ++ public static Vector256<short> ShiftLeftLogicalVariable(Vector256<short> value, Vector256<ushort> count); ++ public static Vector256<ushort> ShiftLeftLogicalVariable(Vector256<ushort> value, Vector256<ushort> count); ++ public static Vector128<long> ShiftRightArithmetic(Vector128<long> value, byte count); ++ public static Vector128<long> ShiftRightArithmetic(Vector128<long> value, Vector128<long> count); ++ public static Vector256<long> ShiftRightArithmetic(Vector256<long> value, byte count); ++ public static Vector256<long> ShiftRightArithmetic(Vector256<long> value, Vector128<long> count); ++ public static Vector128<short> ShiftRightArithmeticVariable(Vector128<short> value, Vector128<ushort> count); ++ public static Vector128<long> ShiftRightArithmeticVariable(Vector128<long> value, Vector128<ulong> count); ++ public static Vector256<short> ShiftRightArithmeticVariable(Vector256<short> value, Vector256<ushort> count); ++ public static Vector256<long> ShiftRightArithmeticVariable(Vector256<long> value, Vector256<ulong> count); ++ public static Vector128<short> ShiftRightLogicalVariable(Vector128<short> value, Vector128<ushort> count); ++ public static Vector128<ushort> ShiftRightLogicalVariable(Vector128<ushort> value, Vector128<ushort> count); ++ public static Vector256<short> ShiftRightLogicalVariable(Vector256<short> value, Vector256<ushort> count); ++ public static Vector256<ushort> ShiftRightLogicalVariable(Vector256<ushort> value, Vector256<ushort> count); ++ public static Vector256<double> Shuffle2x128(Vector256<double> left, Vector256<double> right, byte control); ++ public static Vector256<int> Shuffle2x128(Vector256<int> left, Vector256<int> right, byte control); ++ public static Vector256<long> Shuffle2x128(Vector256<long> left, Vector256<long> right, byte control); ++ public static Vector256<float> Shuffle2x128(Vector256<float> left, Vector256<float> right, byte control); ++ public static Vector256<uint> Shuffle2x128(Vector256<uint> left, Vector256<uint> right, byte control); ++ public static Vector256<ulong> Shuffle2x128(Vector256<ulong> left, Vector256<ulong> right, byte control); ++ public static Vector128<double> SqrtScalar(Vector128<double> upper, Vector128<double> value, FloatRoundingMode mode); ++ public static Vector128<float> SqrtScalar(Vector128<float> upper, Vector128<float> value, FloatRoundingMode mode); ++ public static Vector128<double> SubtractScalar(Vector128<double> left, Vector128<double> right, FloatRoundingMode mode); ++ public static Vector128<float> SubtractScalar(Vector128<float> left, Vector128<float> right, FloatRoundingMode mode); ++ public static Vector128<ushort> SumAbsoluteDifferencesInBlock32(Vector128<byte> left, Vector128<byte> right, byte control); ++ public static Vector256<ushort> SumAbsoluteDifferencesInBlock32(Vector256<byte> left, Vector256<byte> right, byte control); ++ public static Vector128<byte> TernaryLogic(Vector128<byte> a, Vector128<byte> b, Vector128<byte> c, byte control); ++ public static Vector128<double> TernaryLogic(Vector128<double> a, Vector128<double> b, Vector128<double> c, byte control); ++ public static Vector128<short> TernaryLogic(Vector128<short> a, Vector128<short> b, Vector128<short> c, byte control); ++ public static Vector128<int> TernaryLogic(Vector128<int> a, Vector128<int> b, Vector128<int> c, byte control); ++ public static Vector128<long> TernaryLogic(Vector128<long> a, Vector128<long> b, Vector128<long> c, byte control); ++ public static Vector128<sbyte> TernaryLogic(Vector128<sbyte> a, Vector128<sbyte> b, Vector128<sbyte> c, byte control); ++ public static Vector128<float> TernaryLogic(Vector128<float> a, Vector128<float> b, Vector128<float> c, byte control); ++ public static Vector128<ushort> TernaryLogic(Vector128<ushort> a, Vector128<ushort> b, Vector128<ushort> c, byte control); ++ public static Vector128<uint> TernaryLogic(Vector128<uint> a, Vector128<uint> b, Vector128<uint> c, byte control); ++ public static Vector128<ulong> TernaryLogic(Vector128<ulong> a, Vector128<ulong> b, Vector128<ulong> c, byte control); ++ public static Vector256<byte> TernaryLogic(Vector256<byte> a, Vector256<byte> b, Vector256<byte> c, byte control); ++ public static Vector256<double> TernaryLogic(Vector256<double> a, Vector256<double> b, Vector256<double> c, byte control); ++ public static Vector256<short> TernaryLogic(Vector256<short> a, Vector256<short> b, Vector256<short> c, byte control); ++ public static Vector256<int> TernaryLogic(Vector256<int> a, Vector256<int> b, Vector256<int> c, byte control); ++ public static Vector256<long> TernaryLogic(Vector256<long> a, Vector256<long> b, Vector256<long> c, byte control); ++ public static Vector256<sbyte> TernaryLogic(Vector256<sbyte> a, Vector256<sbyte> b, Vector256<sbyte> c, byte control); ++ public static Vector256<float> TernaryLogic(Vector256<float> a, Vector256<float> b, Vector256<float> c, byte control); ++ public static Vector256<ushort> TernaryLogic(Vector256<ushort> a, Vector256<ushort> b, Vector256<ushort> c, byte control); ++ public static Vector256<uint> TernaryLogic(Vector256<uint> a, Vector256<uint> b, Vector256<uint> c, byte control); ++ public static Vector256<ulong> TernaryLogic(Vector256<ulong> a, Vector256<ulong> b, Vector256<ulong> c, byte control); ++ public abstract class V512 : Avx512BW { ++ public static new bool IsSupported { get; } ++ public static Vector512<double> And(Vector512<double> left, Vector512<double> right); ++ public static Vector512<float> And(Vector512<float> left, Vector512<float> right); ++ public static Vector512<double> AndNot(Vector512<double> left, Vector512<double> right); ++ public static Vector512<float> AndNot(Vector512<float> left, Vector512<float> right); ++ public static Vector512<int> BroadcastPairScalarToVector512(Vector128<int> value); ++ public static Vector512<float> BroadcastPairScalarToVector512(Vector128<float> value); ++ public static Vector512<uint> BroadcastPairScalarToVector512(Vector128<uint> value); ++ public unsafe static Vector512<double> BroadcastVector128ToVector512(double* address); ++ public unsafe static Vector512<long> BroadcastVector128ToVector512(long* address); ++ public unsafe static Vector512<ulong> BroadcastVector128ToVector512(ulong* address); ++ public unsafe static Vector512<int> BroadcastVector256ToVector512(int* address); ++ public unsafe static Vector512<float> BroadcastVector256ToVector512(float* address); ++ public unsafe static Vector512<uint> BroadcastVector256ToVector512(uint* address); ++ public static Vector256<float> ConvertToVector256Single(Vector512<long> value); ++ public static Vector256<float> ConvertToVector256Single(Vector512<long> value, FloatRoundingMode mode); ++ public static Vector256<float> ConvertToVector256Single(Vector512<ulong> value); ++ public static Vector256<float> ConvertToVector256Single(Vector512<ulong> value, FloatRoundingMode mode); ++ public static Vector512<double> ConvertToVector512Double(Vector512<long> value); ++ public static Vector512<double> ConvertToVector512Double(Vector512<long> value, FloatRoundingMode mode); ++ public static Vector512<double> ConvertToVector512Double(Vector512<ulong> value); ++ public static Vector512<double> ConvertToVector512Double(Vector512<ulong> value, FloatRoundingMode mode); ++ public static Vector512<long> ConvertToVector512Int64(Vector256<float> value); ++ public static Vector512<long> ConvertToVector512Int64(Vector256<float> value, FloatRoundingMode mode); ++ public static Vector512<long> ConvertToVector512Int64(Vector512<double> value); ++ public static Vector512<long> ConvertToVector512Int64(Vector512<double> value, FloatRoundingMode mode); ++ public static Vector512<long> ConvertToVector512Int64WithTruncation(Vector256<float> value); ++ public static Vector512<long> ConvertToVector512Int64WithTruncation(Vector512<double> value); ++ public static Vector512<ulong> ConvertToVector512UInt64(Vector256<float> value); ++ public static Vector512<ulong> ConvertToVector512UInt64(Vector256<float> value, FloatRoundingMode mode); ++ public static Vector512<ulong> ConvertToVector512UInt64(Vector512<double> value); ++ public static Vector512<ulong> ConvertToVector512UInt64(Vector512<double> value, FloatRoundingMode mode); ++ public static Vector512<ulong> ConvertToVector512UInt64WithTruncation(Vector256<float> value); ++ public static Vector512<ulong> ConvertToVector512UInt64WithTruncation(Vector512<double> value); ++ public static Vector512<int> DetectConflicts(Vector512<int> value); ++ public static Vector512<long> DetectConflicts(Vector512<long> value); ++ public static Vector512<uint> DetectConflicts(Vector512<uint> value); ++ public static Vector512<ulong> DetectConflicts(Vector512<ulong> value); ++ public static new Vector128<double> ExtractVector128(Vector512<double> value, byte index); ++ public static new Vector128<long> ExtractVector128(Vector512<long> value, byte index); ++ public static new Vector128<ulong> ExtractVector128(Vector512<ulong> value, byte index); ++ public static new Vector256<int> ExtractVector256(Vector512<int> value, byte index); ++ public static new Vector256<float> ExtractVector256(Vector512<float> value, byte index); ++ public static new Vector256<uint> ExtractVector256(Vector512<uint> value, byte index); ++ public static new Vector512<double> InsertVector128(Vector512<double> value, Vector128<double> data, byte index); ++ public static new Vector512<long> InsertVector128(Vector512<long> value, Vector128<long> data, byte index); ++ public static new Vector512<ulong> InsertVector128(Vector512<ulong> value, Vector128<ulong> data, byte index); ++ public static new Vector512<int> InsertVector256(Vector512<int> value, Vector256<int> data, byte index); ++ public static new Vector512<float> InsertVector256(Vector512<float> value, Vector256<float> data, byte index); ++ public static new Vector512<uint> InsertVector256(Vector512<uint> value, Vector256<uint> data, byte index); ++ public static Vector512<int> LeadingZeroCount(Vector512<int> value); ++ public static Vector512<long> LeadingZeroCount(Vector512<long> value); ++ public static Vector512<uint> LeadingZeroCount(Vector512<uint> value); ++ public static Vector512<ulong> LeadingZeroCount(Vector512<ulong> value); ++ public static Vector512<long> MultiplyLow(Vector512<long> left, Vector512<long> right); ++ public static Vector512<ulong> MultiplyLow(Vector512<ulong> left, Vector512<ulong> right); ++ public static Vector512<byte> MultiShift(Vector512<byte> control, Vector512<ulong> value); ++ public static Vector512<sbyte> MultiShift(Vector512<sbyte> control, Vector512<long> value); ++ public static Vector512<double> Or(Vector512<double> left, Vector512<double> right); ++ public static Vector512<float> Or(Vector512<float> left, Vector512<float> right); ++ public static Vector512<byte> PermuteVar64x8(Vector512<byte> left, Vector512<byte> control); ++ public static Vector512<sbyte> PermuteVar64x8(Vector512<sbyte> left, Vector512<sbyte> control); ++ public static Vector512<byte> PermuteVar64x8x2(Vector512<byte> lower, Vector512<byte> indices, Vector512<byte> upper); ++ public static Vector512<sbyte> PermuteVar64x8x2(Vector512<sbyte> lower, Vector512<sbyte> indices, Vector512<sbyte> upper); ++ public static Vector512<double> Range(Vector512<double> left, Vector512<double> right, byte control); ++ public static Vector512<float> Range(Vector512<float> left, Vector512<float> right, byte control); ++ public static Vector512<double> Reduce(Vector512<double> value, byte control); ++ public static Vector512<float> Reduce(Vector512<float> value, byte control); ++ public static Vector512<double> Xor(Vector512<double> left, Vector512<double> right); ++ public static Vector512<float> Xor(Vector512<float> left, Vector512<float> right); ++ public new abstract class X64 : Avx512BW.X64 { ++ public static new bool IsSupported { get; } ++ } ++ } ++ public new abstract class X64 : Avx2.X64 { ++ public static new bool IsSupported { get; } ++ public static Vector128<double> ConvertScalarToVector128Double(Vector128<double> upper, long value, FloatRoundingMode mode); ++ public static Vector128<double> ConvertScalarToVector128Double(Vector128<double> upper, ulong value); ++ public static Vector128<double> ConvertScalarToVector128Double(Vector128<double> upper, ulong value, FloatRoundingMode mode); ++ public static Vector128<float> ConvertScalarToVector128Single(Vector128<float> upper, long value, FloatRoundingMode mode); ++ public static Vector128<float> ConvertScalarToVector128Single(Vector128<float> upper, ulong value); ++ public static Vector128<float> ConvertScalarToVector128Single(Vector128<float> upper, ulong value, FloatRoundingMode mode); ++ public static long ConvertToInt64(Vector128<double> value, FloatRoundingMode mode); ++ public static long ConvertToInt64(Vector128<float> value, FloatRoundingMode mode); ++ public static ulong ConvertToUInt64(Vector128<double> value); ++ public static ulong ConvertToUInt64(Vector128<double> value, FloatRoundingMode mode); ++ public static ulong ConvertToUInt64(Vector128<float> value); ++ public static ulong ConvertToUInt64(Vector128<float> value, FloatRoundingMode mode); ++ public static ulong ConvertToUInt64WithTruncation(Vector128<double> value); ++ public static ulong ConvertToUInt64WithTruncation(Vector128<float> value); ++ } ++ } + public abstract class Avx512Vbmi : Avx512BW { ++ public static Vector512<byte> MultiShift(Vector512<byte> control, Vector512<ulong> value); ++ public static Vector512<sbyte> MultiShift(Vector512<sbyte> control, Vector512<long> value); + public new abstract class VL : Avx512BW.VL { ++ public static Vector128<byte> MultiShift(Vector128<byte> control, Vector128<ulong> value); ++ public static Vector128<sbyte> MultiShift(Vector128<sbyte> control, Vector128<long> value); ++ public static Vector256<byte> MultiShift(Vector256<byte> control, Vector256<ulong> value); ++ public static Vector256<sbyte> MultiShift(Vector256<sbyte> control, Vector256<long> value); + } + } + } +``` + diff --git a/release-notes/9.0/preview/preview6/api-diff/Microsoft.NETCore.App/9.0-preview6_System.Runtime.Intrinsics.md b/release-notes/9.0/preview/preview6/api-diff/Microsoft.NETCore.App/9.0-preview6_System.Runtime.Intrinsics.md new file mode 100644 index 0000000000..087b6388bb --- /dev/null +++ b/release-notes/9.0/preview/preview6/api-diff/Microsoft.NETCore.App/9.0-preview6_System.Runtime.Intrinsics.md @@ -0,0 +1,21 @@ +# System.Runtime.Intrinsics + +``` diff + namespace System.Runtime.Intrinsics { + public static class Vector128 { ++ public static Vector128<Single> AsVector128Unsafe(this Vector2 value); ++ public static Vector128<Single> AsVector128Unsafe(this Vector3 value); ++ public static Vector128<T> Create<T>(Vector64<T> value); + } + public static class Vector256 { ++ public static Vector256<T> Create<T>(Vector128<T> value); ++ public static Vector256<T> Create<T>(Vector64<T> value); + } + public static class Vector512 { ++ public static Vector512<T> Create<T>(Vector128<T> value); ++ public static Vector512<T> Create<T>(Vector256<T> value); ++ public static Vector512<T> Create<T>(Vector64<T> value); + } + } +``` + diff --git a/release-notes/9.0/preview/preview6/api-diff/Microsoft.NETCore.App/9.0-preview6_System.Security.Cryptography.md b/release-notes/9.0/preview/preview6/api-diff/Microsoft.NETCore.App/9.0-preview6_System.Security.Cryptography.md new file mode 100644 index 0000000000..7bfa867f2d --- /dev/null +++ b/release-notes/9.0/preview/preview6/api-diff/Microsoft.NETCore.App/9.0-preview6_System.Security.Cryptography.md @@ -0,0 +1,22 @@ +# System.Security.Cryptography + +``` diff + namespace System.Security.Cryptography { + public sealed class IncrementalHash : IDisposable { ++ public IncrementalHash Clone(); + } + public sealed class Kmac128 : IDisposable { ++ public Kmac128 Clone(); + } + public sealed class Kmac256 : IDisposable { ++ public Kmac256 Clone(); + } + public sealed class KmacXof128 : IDisposable { ++ public KmacXof128 Clone(); + } + public sealed class KmacXof256 : IDisposable { ++ public KmacXof256 Clone(); + } + } +``` + diff --git a/release-notes/9.0/preview/preview6/api-diff/Microsoft.NETCore.App/9.0-preview6_System.Text.Json.Nodes.md b/release-notes/9.0/preview/preview6/api-diff/Microsoft.NETCore.App/9.0-preview6_System.Text.Json.Nodes.md new file mode 100644 index 0000000000..c1d9bee1f4 --- /dev/null +++ b/release-notes/9.0/preview/preview6/api-diff/Microsoft.NETCore.App/9.0-preview6_System.Text.Json.Nodes.md @@ -0,0 +1,20 @@ +# System.Text.Json.Nodes + +``` diff + namespace System.Text.Json.Nodes { +- public sealed class JsonObject : JsonNode, ICollection<KeyValuePair<string, JsonNode?>>, IDictionary<string, JsonNode?>, IEnumerable, IEnumerable<KeyValuePair<string, JsonNode?>> { ++ public sealed class JsonObject : JsonNode, ICollection<KeyValuePair<string, JsonNode?>>, IDictionary<string, JsonNode?>, IEnumerable, IEnumerable<KeyValuePair<string, JsonNode?>>, IList<KeyValuePair<string, JsonNode?>> { ++ KeyValuePair<string, JsonNode?> IList<KeyValuePair<string, JsonNode?>>.this[int index] { get; set; } ++ public KeyValuePair<string, JsonNode?> GetAt(int index); ++ public int IndexOf(string propertyName); ++ public void Insert(int index, string propertyName, JsonNode? value); ++ public void RemoveAt(int index); ++ public void SetAt(int index, string propertyName, JsonNode? value); ++ public void SetAt(int index, JsonNode? value); ++ int IList<KeyValuePair<string, JsonNode?>>.IndexOf(KeyValuePair<string, JsonNode> item); ++ void IList<KeyValuePair<string, JsonNode?>>.Insert(int index, KeyValuePair<string, JsonNode> item); ++ void IList<KeyValuePair<string, JsonNode?>>.RemoveAt(int index); + } + } +``` + diff --git a/release-notes/9.0/preview/preview6/api-diff/Microsoft.NETCore.App/9.0-preview6_System.Text.Json.Schema.md b/release-notes/9.0/preview/preview6/api-diff/Microsoft.NETCore.App/9.0-preview6_System.Text.Json.Schema.md new file mode 100644 index 0000000000..e12ec24342 --- /dev/null +++ b/release-notes/9.0/preview/preview6/api-diff/Microsoft.NETCore.App/9.0-preview6_System.Text.Json.Schema.md @@ -0,0 +1,22 @@ +# System.Text.Json.Schema + +``` diff ++namespace System.Text.Json.Schema { ++ public static class JsonSchemaExporter { ++ public static JsonNode GetJsonSchemaAsNode(this JsonSerializerOptions options, Type type, JsonSchemaExporterOptions? exporterOptions = null); ++ public static JsonNode GetJsonSchemaAsNode(this JsonTypeInfo typeInfo, JsonSchemaExporterOptions? exporterOptions = null); ++ } ++ public readonly struct JsonSchemaExporterContext { ++ public ReadOnlySpan<string> Path { get; } ++ public JsonPropertyInfo? PropertyInfo { get; } ++ public JsonTypeInfo TypeInfo { get; } ++ } ++ public sealed class JsonSchemaExporterOptions { ++ public JsonSchemaExporterOptions(); ++ public static JsonSchemaExporterOptions Default { get; } ++ public Func<JsonSchemaExporterContext, JsonNode, JsonNode>? TransformSchemaNode { get; set; } ++ public bool TreatNullObliviousAsNonNullable { get; set; } ++ } ++} +``` + diff --git a/release-notes/9.0/preview/preview6/api-diff/Microsoft.NETCore.App/9.0-preview6_System.Text.Json.Serialization.Metadata.md b/release-notes/9.0/preview/preview6/api-diff/Microsoft.NETCore.App/9.0-preview6_System.Text.Json.Serialization.Metadata.md new file mode 100644 index 0000000000..2875751aba --- /dev/null +++ b/release-notes/9.0/preview/preview6/api-diff/Microsoft.NETCore.App/9.0-preview6_System.Text.Json.Serialization.Metadata.md @@ -0,0 +1,36 @@ +# System.Text.Json.Serialization.Metadata + +``` diff + namespace System.Text.Json.Serialization.Metadata { + public sealed class JsonObjectInfoValues<T> { ++ public Func<ICustomAttributeProvider>? ConstructorAttributeProviderFactory { get; set; } + } ++ public abstract class JsonParameterInfo { ++ public ICustomAttributeProvider? AttributeProvider { get; } ++ public Type DeclaringType { get; } ++ public object? DefaultValue { get; } ++ public bool HasDefaultValue { get; } ++ public bool IsMemberInitializer { get; } ++ public bool IsNullable { get; } ++ public string Name { get; } ++ public Type ParameterType { get; } ++ public int Position { get; } ++ } + public sealed class JsonParameterInfoValues { ++ public bool IsMemberInitializer { get; set; } + } + public abstract class JsonPropertyInfo { ++ public JsonParameterInfo? AssociatedParameter { get; } ++ public Type DeclaringType { get; } + } + public sealed class JsonPropertyInfoValues<T> { ++ public Func<ICustomAttributeProvider>? AttributeProviderFactory { get; set; } + } + public abstract class JsonTypeInfo { ++ public ICustomAttributeProvider ConstructorAttributeProvider { get; } ++ public Type ElementType { get; } ++ public Type KeyType { get; } + } + } +``` + diff --git a/release-notes/9.0/preview/preview6/api-diff/Microsoft.NETCore.App/9.0-preview6_System.Text.Json.Serialization.md b/release-notes/9.0/preview/preview6/api-diff/Microsoft.NETCore.App/9.0-preview6_System.Text.Json.Serialization.md new file mode 100644 index 0000000000..285162e0c4 --- /dev/null +++ b/release-notes/9.0/preview/preview6/api-diff/Microsoft.NETCore.App/9.0-preview6_System.Text.Json.Serialization.md @@ -0,0 +1,10 @@ +# System.Text.Json.Serialization + +``` diff + namespace System.Text.Json.Serialization { + public sealed class JsonSourceGenerationOptionsAttribute : JsonAttribute { ++ public bool RespectRequiredConstructorParameters { get; set; } + } + } +``` + diff --git a/release-notes/9.0/preview/preview6/api-diff/Microsoft.NETCore.App/9.0-preview6_System.Text.Json.md b/release-notes/9.0/preview/preview6/api-diff/Microsoft.NETCore.App/9.0-preview6_System.Text.Json.md new file mode 100644 index 0000000000..2312acf0a5 --- /dev/null +++ b/release-notes/9.0/preview/preview6/api-diff/Microsoft.NETCore.App/9.0-preview6_System.Text.Json.md @@ -0,0 +1,10 @@ +# System.Text.Json + +``` diff + namespace System.Text.Json { + public sealed class JsonSerializerOptions { ++ public bool RespectRequiredConstructorParameters { get; set; } + } + } +``` + diff --git a/release-notes/9.0/preview/preview6/api-diff/Microsoft.NETCore.App/9.0-preview6_System.Text.RegularExpressions.md b/release-notes/9.0/preview/preview6/api-diff/Microsoft.NETCore.App/9.0-preview6_System.Text.RegularExpressions.md new file mode 100644 index 0000000000..743954200a --- /dev/null +++ b/release-notes/9.0/preview/preview6/api-diff/Microsoft.NETCore.App/9.0-preview6_System.Text.RegularExpressions.md @@ -0,0 +1,20 @@ +# System.Text.RegularExpressions + +``` diff + namespace System.Text.RegularExpressions { + public class Regex : ISerializable { ++ public Regex.ValueSplitEnumerator EnumerateSplits(ReadOnlySpan<char> input); ++ public Regex.ValueSplitEnumerator EnumerateSplits(ReadOnlySpan<char> input, int count); ++ public Regex.ValueSplitEnumerator EnumerateSplits(ReadOnlySpan<char> input, int count, int startat); ++ public static Regex.ValueSplitEnumerator EnumerateSplits(ReadOnlySpan<char> input, string pattern); ++ public static Regex.ValueSplitEnumerator EnumerateSplits(ReadOnlySpan<char> input, string pattern, RegexOptions options); ++ public static Regex.ValueSplitEnumerator EnumerateSplits(ReadOnlySpan<char> input, string pattern, RegexOptions options, TimeSpan matchTimeout); ++ public ref struct ValueSplitEnumerator { ++ public Range Current { get; } ++ public Regex.ValueSplitEnumerator GetEnumerator(); ++ public bool MoveNext(); ++ } + } + } +``` + diff --git a/release-notes/9.0/preview/preview6/api-diff/Microsoft.NETCore.App/9.0-preview6_System.md b/release-notes/9.0/preview/preview6/api-diff/Microsoft.NETCore.App/9.0-preview6_System.md new file mode 100644 index 0000000000..f937acb14f --- /dev/null +++ b/release-notes/9.0/preview/preview6/api-diff/Microsoft.NETCore.App/9.0-preview6_System.md @@ -0,0 +1,32 @@ +# System + +``` diff + namespace System { + public readonly struct Int32 : IAdditionOperators<int, int, int>, IAdditiveIdentity<int, int>, IBinaryInteger<int>, IBinaryNumber<int>, IBitwiseOperators<int, int, int>, IComparable, IComparable<int>, IComparisonOperators<int, int, bool>, IConvertible, IDecrementOperators<int>, IDivisionOperators<int, int, int>, IEqualityOperators<int, int, bool>, IEquatable<int>, IFormattable, IIncrementOperators<int>, IMinMaxValue<int>, IModulusOperators<int, int, int>, IMultiplicativeIdentity<int, int>, IMultiplyOperators<int, int, int>, INumber<int>, INumberBase<int>, IParsable<int>, IShiftOperators<int, int, int>, ISignedNumber<int>, ISpanFormattable, ISpanParsable<int>, ISubtractionOperators<int, int, int>, IUnaryNegationOperators<int, int>, IUnaryPlusOperators<int, int>, IUtf8SpanFormattable, IUtf8SpanParsable<int> { ++ public static long BigMul(Int32 left, Int32 right); + } + public readonly struct Int64 : IAdditionOperators<long, long, long>, IAdditiveIdentity<long, long>, IBinaryInteger<long>, IBinaryNumber<long>, IBitwiseOperators<long, long, long>, IComparable, IComparable<long>, IComparisonOperators<long, long, bool>, IConvertible, IDecrementOperators<long>, IDivisionOperators<long, long, long>, IEqualityOperators<long, long, bool>, IEquatable<long>, IFormattable, IIncrementOperators<long>, IMinMaxValue<long>, IModulusOperators<long, long, long>, IMultiplicativeIdentity<long, long>, IMultiplyOperators<long, long, long>, INumber<long>, INumberBase<long>, IParsable<long>, IShiftOperators<long, int, long>, ISignedNumber<long>, ISpanFormattable, ISpanParsable<long>, ISubtractionOperators<long, long, long>, IUnaryNegationOperators<long, long>, IUnaryPlusOperators<long, long>, IUtf8SpanFormattable, IUtf8SpanParsable<long> { ++ public static Int128 BigMul(Int64 left, Int64 right); + } + public static class Math { ++ public static Int128 BigMul(long a, long b); ++ public static ulong BigMul(uint a, uint b); ++ public static UInt128 BigMul(ulong a, ulong b); + } + public static class MemoryExtensions { ++ public static bool EndsWith<T>(this ReadOnlySpan<T> span, T value) where T : IEquatable<T>?; ++ public static bool StartsWith<T>(this ReadOnlySpan<T> span, T value) where T : IEquatable<T>?; + } + public readonly struct UInt32 : IAdditionOperators<uint, uint, uint>, IAdditiveIdentity<uint, uint>, IBinaryInteger<uint>, IBinaryNumber<uint>, IBitwiseOperators<uint, uint, uint>, IComparable, IComparable<uint>, IComparisonOperators<uint, uint, bool>, IConvertible, IDecrementOperators<uint>, IDivisionOperators<uint, uint, uint>, IEqualityOperators<uint, uint, bool>, IEquatable<uint>, IFormattable, IIncrementOperators<uint>, IMinMaxValue<uint>, IModulusOperators<uint, uint, uint>, IMultiplicativeIdentity<uint, uint>, IMultiplyOperators<uint, uint, uint>, INumber<uint>, INumberBase<uint>, IParsable<uint>, IShiftOperators<uint, int, uint>, ISpanFormattable, ISpanParsable<uint>, ISubtractionOperators<uint, uint, uint>, IUnaryNegationOperators<uint, uint>, IUnaryPlusOperators<uint, uint>, IUnsignedNumber<uint>, IUtf8SpanFormattable, IUtf8SpanParsable<uint> { ++ public static ulong BigMul(UInt32 left, UInt32 right); + } + public readonly struct UInt64 : IAdditionOperators<ulong, ulong, ulong>, IAdditiveIdentity<ulong, ulong>, IBinaryInteger<ulong>, IBinaryNumber<ulong>, IBitwiseOperators<ulong, ulong, ulong>, IComparable, IComparable<ulong>, IComparisonOperators<ulong, ulong, bool>, IConvertible, IDecrementOperators<ulong>, IDivisionOperators<ulong, ulong, ulong>, IEqualityOperators<ulong, ulong, bool>, IEquatable<ulong>, IFormattable, IIncrementOperators<ulong>, IMinMaxValue<ulong>, IModulusOperators<ulong, ulong, ulong>, IMultiplicativeIdentity<ulong, ulong>, IMultiplyOperators<ulong, ulong, ulong>, INumber<ulong>, INumberBase<ulong>, IParsable<ulong>, IShiftOperators<ulong, int, ulong>, ISpanFormattable, ISpanParsable<ulong>, ISubtractionOperators<ulong, ulong, ulong>, IUnaryNegationOperators<ulong, ulong>, IUnaryPlusOperators<ulong, ulong>, IUnsignedNumber<ulong>, IUtf8SpanFormattable, IUtf8SpanParsable<ulong> { ++ public static UInt128 BigMul(UInt64 left, UInt64 right); + } +- public class Uri : IFormattable, ISerializable, ISpanFormattable { ++ public class Uri : IEquatable<Uri>, IFormattable, ISerializable, ISpanFormattable { ++ public bool Equals(Uri? other); + } + } +``` + diff --git a/release-notes/9.0/preview/preview6/api-diff/Microsoft.WindowsDesktop.App/9.0-preview6.md b/release-notes/9.0/preview/preview6/api-diff/Microsoft.WindowsDesktop.App/9.0-preview6.md new file mode 100644 index 0000000000..3102900b0b --- /dev/null +++ b/release-notes/9.0/preview/preview6/api-diff/Microsoft.WindowsDesktop.App/9.0-preview6.md @@ -0,0 +1,10 @@ +# API Difference 9.0-preview5 vs 9.0-preview6 + +API listing follows standard diff formatting. +Lines preceded by a '+' are additions and a '-' indicates removal. + +* [System.Drawing](9.0-preview6_System.Drawing.md) +* [System.Drawing.Drawing2D](9.0-preview6_System.Drawing.Drawing2D.md) +* [System.Formats.Nrbf](9.0-preview6_System.Formats.Nrbf.md) +* [System.Windows.Forms.Design](9.0-preview6_System.Windows.Forms.Design.md) + diff --git a/release-notes/9.0/preview/preview6/api-diff/Microsoft.WindowsDesktop.App/9.0-preview6_System.Drawing.Drawing2D.md b/release-notes/9.0/preview/preview6/api-diff/Microsoft.WindowsDesktop.App/9.0-preview6_System.Drawing.Drawing2D.md new file mode 100644 index 0000000000..8fbdbc9be1 --- /dev/null +++ b/release-notes/9.0/preview/preview6/api-diff/Microsoft.WindowsDesktop.App/9.0-preview6_System.Drawing.Drawing2D.md @@ -0,0 +1,46 @@ +# System.Drawing.Drawing2D + +``` diff + namespace System.Drawing.Drawing2D { + public sealed class GraphicsPath : MarshalByRefObject, ICloneable, IDisposable { +- public void AddPolygon(PointF[] points); ++ public void AddPolygon(params PointF[] points); +- public void AddPolygon(Point[] points); ++ public void AddPolygon(params Point[] points); +- public void AddRectangles(Rectangle[] rects); ++ public void AddRectangles(params Rectangle[] rects); + } + public sealed class Matrix : MarshalByRefObject, IDisposable { +- public Matrix(Rectangle rect, Point[] plgpts); ++ public Matrix(Rectangle rect, params Point[] plgpts); +- public Matrix(RectangleF rect, PointF[] plgpts); ++ public Matrix(RectangleF rect, params PointF[] plgpts); +- public void TransformPoints(PointF[] pts); ++ public void TransformPoints(params PointF[] pts); +- public void TransformPoints(Point[] pts); ++ public void TransformPoints(params Point[] pts); ++ public void TransformPoints(ReadOnlySpan<Point> pts); ++ public void TransformPoints(ReadOnlySpan<PointF> pts); +- public void TransformVectors(PointF[] pts); ++ public void TransformVectors(params PointF[] pts); +- public void TransformVectors(Point[] pts); ++ public void TransformVectors(params Point[] pts); ++ public void TransformVectors(ReadOnlySpan<Point> pts); ++ public void TransformVectors(ReadOnlySpan<PointF> pts); +- public void VectorTransformPoints(Point[] pts); ++ public void VectorTransformPoints(params Point[] pts); ++ public void VectorTransformPoints(ReadOnlySpan<Point> pts); + } + public sealed class PathGradientBrush : Brush { ++ public PathGradientBrush(WrapMode wrapMode, ReadOnlySpan<Point> points); ++ public PathGradientBrush(WrapMode wrapMode, ReadOnlySpan<PointF> points); +- public PathGradientBrush(PointF[] points); ++ public PathGradientBrush(params PointF[] points); +- public PathGradientBrush(Point[] points); ++ public PathGradientBrush(params Point[] points); ++ public PathGradientBrush(ReadOnlySpan<Point> points); ++ public PathGradientBrush(ReadOnlySpan<PointF> points); + } + } +``` + diff --git a/release-notes/9.0/preview/preview6/api-diff/Microsoft.WindowsDesktop.App/9.0-preview6_System.Drawing.md b/release-notes/9.0/preview/preview6/api-diff/Microsoft.WindowsDesktop.App/9.0-preview6_System.Drawing.md new file mode 100644 index 0000000000..109f484cac --- /dev/null +++ b/release-notes/9.0/preview/preview6/api-diff/Microsoft.WindowsDesktop.App/9.0-preview6_System.Drawing.md @@ -0,0 +1,19 @@ +# System.Drawing + +``` diff + namespace System.Drawing { + public sealed class Graphics : MarshalByRefObject, IDeviceContext, IDisposable, IGraphics, IGraphicsContextInfo, IHdcContext, IPointer<GpGraphics> { +- public void DrawClosedCurve(Pen pen, Point[] points); ++ public void DrawClosedCurve(Pen pen, params Point[] points); +- public void DrawLines(Pen pen, PointF[] points); ++ public void DrawLines(Pen pen, params PointF[] points); +- public void TransformPoints(CoordinateSpace destSpace, CoordinateSpace srcSpace, PointF[] pts); ++ public void TransformPoints(CoordinateSpace destSpace, CoordinateSpace srcSpace, params PointF[] pts); +- public void TransformPoints(CoordinateSpace destSpace, CoordinateSpace srcSpace, Point[] pts); ++ public void TransformPoints(CoordinateSpace destSpace, CoordinateSpace srcSpace, params Point[] pts); ++ public void TransformPoints(CoordinateSpace destSpace, CoordinateSpace srcSpace, ReadOnlySpan<Point> pts); ++ public void TransformPoints(CoordinateSpace destSpace, CoordinateSpace srcSpace, ReadOnlySpan<PointF> pts); + } + } +``` + diff --git a/release-notes/9.0/preview/preview6/api-diff/Microsoft.WindowsDesktop.App/9.0-preview6_System.Formats.Nrbf.md b/release-notes/9.0/preview/preview6/api-diff/Microsoft.WindowsDesktop.App/9.0-preview6_System.Formats.Nrbf.md new file mode 100644 index 0000000000..62e56357e2 --- /dev/null +++ b/release-notes/9.0/preview/preview6/api-diff/Microsoft.WindowsDesktop.App/9.0-preview6_System.Formats.Nrbf.md @@ -0,0 +1,96 @@ +# System.Formats.Nrbf + +``` diff ++namespace System.Formats.Nrbf { ++ public abstract class ArrayRecord : SerializationRecord { ++ public override SerializationRecordId Id { get; } ++ public abstract ReadOnlySpan<int> Lengths { get; } ++ public int Rank { get; } ++ public Array GetArray(Type expectedArrayType, bool allowNulls = true); ++ } ++ public abstract class ClassRecord : SerializationRecord { ++ public override SerializationRecordId Id { get; } ++ public IEnumerable<string> MemberNames { get; } ++ public override TypeName TypeName { get; } ++ public ArrayRecord? GetArrayRecord(string memberName); ++ public bool GetBoolean(string memberName); ++ public byte GetByte(string memberName); ++ public char GetChar(string memberName); ++ public ClassRecord? GetClassRecord(string memberName); ++ public DateTime GetDateTime(string memberName); ++ public decimal GetDecimal(string memberName); ++ public double GetDouble(string memberName); ++ public short GetInt16(string memberName); ++ public int GetInt32(string memberName); ++ public long GetInt64(string memberName); ++ public object? GetRawValue(string memberName); ++ public sbyte GetSByte(string memberName); ++ public SerializationRecord? GetSerializationRecord(string memberName); ++ public float GetSingle(string memberName); ++ public string? GetString(string memberName); ++ public TimeSpan GetTimeSpan(string memberName); ++ public ushort GetUInt16(string memberName); ++ public uint GetUInt32(string memberName); ++ public ulong GetUInt64(string memberName); ++ public bool HasMember(string memberName); ++ } ++ public static class NrbfDecoder { ++ public static SerializationRecord Decode(Stream payload, out IReadOnlyDictionary<SerializationRecordId, SerializationRecord> recordMap, PayloadOptions options = null, bool leaveOpen = false); ++ public static SerializationRecord Decode(Stream payload, PayloadOptions? options = null, bool leaveOpen = false); ++ public static ClassRecord DecodeClassRecord(Stream payload, PayloadOptions? options = null, bool leaveOpen = false); ++ public static bool StartsWithPayloadHeader(byte[] bytes); ++ public static bool StartsWithPayloadHeader(Stream stream); ++ } ++ public sealed class PayloadOptions { ++ public PayloadOptions(); ++ public TypeNameParseOptions TypeNameParseOptions { get; set; } ++ public bool UndoTruncatedTypeNames { get; set; } ++ } ++ public abstract class PrimitiveTypeRecord : SerializationRecord { ++ public object Value { get; } ++ } ++ public abstract class PrimitiveTypeRecord<T> : PrimitiveTypeRecord { ++ public override TypeName TypeName { get; } ++ public new T Value { get; } ++ } ++ public abstract class SerializationRecord { ++ public abstract SerializationRecordId Id { get; } ++ public abstract SerializationRecordType RecordType { get; } ++ public abstract TypeName TypeName { get; } ++ public bool TypeNameMatches(Type type); ++ } ++ public struct SerializationRecordId : IEquatable<SerializationRecordId> { ++ public bool Equals(SerializationRecordId other); ++ public override bool Equals(object? obj); ++ public override int GetHashCode(); ++ } ++ public enum SerializationRecordType { ++ ArraySingleObject = 16, ++ ArraySinglePrimitive = 15, ++ ArraySingleString = 17, ++ BinaryArray = 7, ++ BinaryLibrary = 12, ++ BinaryObjectString = 6, ++ ClassWithId = 1, ++ ClassWithMembers = 3, ++ ClassWithMembersAndTypes = 5, ++ MemberPrimitiveTyped = 8, ++ MemberReference = 9, ++ MessageEnd = 11, ++ MethodCall = 21, ++ MethodReturn = 22, ++ ObjectNull = 10, ++ ObjectNullMultiple = 14, ++ ObjectNullMultiple256 = 13, ++ SerializedStreamHeader = 0, ++ SystemClassWithMembers = 2, ++ SystemClassWithMembersAndTypes = 4, ++ } ++ public abstract class SZArrayRecord<T> : ArrayRecord { ++ public int Length { get; } ++ public override ReadOnlySpan<int> Lengths { get; } ++ public abstract T?[] GetArray(bool allowNulls = true); ++ } ++} +``` + diff --git a/release-notes/9.0/preview/preview6/api-diff/Microsoft.WindowsDesktop.App/9.0-preview6_System.Windows.Forms.Design.md b/release-notes/9.0/preview/preview6/api-diff/Microsoft.WindowsDesktop.App/9.0-preview6_System.Windows.Forms.Design.md new file mode 100644 index 0000000000..db1400421f --- /dev/null +++ b/release-notes/9.0/preview/preview6/api-diff/Microsoft.WindowsDesktop.App/9.0-preview6_System.Windows.Forms.Design.md @@ -0,0 +1,13 @@ +# System.Windows.Forms.Design + +``` diff + namespace System.Windows.Forms.Design { + public class ControlDesigner : ComponentDesigner { +- public override void InitializeExistingComponent(IDictionary defaultValues); ++ public override void InitializeExistingComponent(IDictionary? defaultValues); +- public override void InitializeNewComponent(IDictionary defaultValues); ++ public override void InitializeNewComponent(IDictionary? defaultValues); + } + } +``` + diff --git a/release-notes/9.0/preview/preview6/api-diff/README.md b/release-notes/9.0/preview/preview6/api-diff/README.md new file mode 100644 index 0000000000..da11f72f6f --- /dev/null +++ b/release-notes/9.0/preview/preview6/api-diff/README.md @@ -0,0 +1,7 @@ +# .NET 9.0 Preview 6 API Changes + +The following API changes were made in .NET 9.0 Preview 6: + +- [Microsoft.NETCore.App](./Microsoft.NETCore.App/9.0-preview6.md) +- [Microsoft.AspNetCore.App](./Microsoft.AspNetCore.App/9.0-preview6.md) +- [Microsoft.WindowsDesktop.App](./Microsoft.WindowsDesktop.App/9.0-preview6.md)